@fgv/ts-sudoku-lib 5.0.1-0 → 5.0.1-2

package/lib/packlets/files/converters.d.ts

@@ -0,0 +1,27 @@
+import { Converter, Result } from '@fgv/ts-utils';
+import { IPuzzlesFile, IPuzzleFileData, IPuzzleFileDimensions } from './model';
+import { FileTree } from '@fgv/ts-json-base';
+/**
+ * Converts puzzle file dimensions from JSON format
+ * @public
+ */
+export declare const puzzleFileDimensions: Converter<IPuzzleFileDimensions>;
+/**
+ * Converts puzzle file data from JSON format
+ * @public
+ */
+export declare const puzzleFileData: Converter<IPuzzleFileData>;
+/**
+ * Converts an arbitrary object to a {@link Files.Model.IPuzzlesFile | IPuzzlesFile}.
+ * @public
+ */
+export declare const puzzlesFile: Converter<IPuzzlesFile>;
+/**
+ * Loads a puzzles file from a `IFileTreeFileItem`.
+ * @param file - The `IFileTreeFileItem` to load.
+ * @returns `Success` with the resulting {@link Files.Model.IPuzzlesFile | IPuzzlesFile}, or `Failure` with
+ * details if an error occurs.
+ * @public
+ */
+export declare function loadPuzzlesFile(file: FileTree.IFileTreeFileItem): Result<IPuzzlesFile>;
+//# sourceMappingURL=converters.d.ts.map

package/lib/packlets/files/converters.js

@@ -0,0 +1,71 @@
+"use strict";
+/*
+ * MIT License
+ *
+ * Copyright (c) 2023 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.puzzlesFile = exports.puzzleFileData = exports.puzzleFileDimensions = void 0;
+exports.loadPuzzlesFile = loadPuzzlesFile;
+const ts_utils_1 = require("@fgv/ts-utils");
+const common_1 = require("../common");
+/**
+ * Converts puzzle file dimensions from JSON format
+ * @public
+ */
+exports.puzzleFileDimensions = ts_utils_1.Converters.strictObject({
+    cageWidthInCells: ts_utils_1.Converters.number,
+    cageHeightInCells: ts_utils_1.Converters.number,
+    boardWidthInCages: ts_utils_1.Converters.number,
+    boardHeightInCages: ts_utils_1.Converters.number
+});
+/**
+ * Converts puzzle file data from JSON format
+ * @public
+ */
+exports.puzzleFileData = ts_utils_1.Converters.strictObject({
+    id: ts_utils_1.Converters.string,
+    description: ts_utils_1.Converters.string,
+    type: common_1.Converters.puzzleType,
+    level: ts_utils_1.Converters.number,
+    cells: ts_utils_1.Converters.oneOf([ts_utils_1.Converters.string, ts_utils_1.Converters.stringArray.map((s) => (0, ts_utils_1.succeed)(s.join('')))]),
+    dimensions: exports.puzzleFileDimensions
+}, {
+    optionalFields: ['id']
+});
+/**
+ * Converts an arbitrary object to a {@link Files.Model.IPuzzlesFile | IPuzzlesFile}.
+ * @public
+ */
+exports.puzzlesFile = ts_utils_1.Converters.strictObject({
+    puzzles: ts_utils_1.Converters.arrayOf(exports.puzzleFileData)
+});
+/**
+ * Loads a puzzles file from a `IFileTreeFileItem`.
+ * @param file - The `IFileTreeFileItem` to load.
+ * @returns `Success` with the resulting {@link Files.Model.IPuzzlesFile | IPuzzlesFile}, or `Failure` with
+ * details if an error occurs.
+ * @public
+ */
+function loadPuzzlesFile(file) {
+    return file.getContents(exports.puzzlesFile);
+}
+//# sourceMappingURL=converters.js.map

package/lib/packlets/{file/converters.d.ts → files/filesystem.d.ts}

@@ -1,17 +1,12 @@
-import { Converter, Result } from '@fgv/ts-utils';
+import { Result } from '@fgv/ts-utils';
 import { IPuzzlesFile } from './model';
-/**
- * Converts an arbitrary object to a {@link File.Model.IPuzzlesFile | IPuzzlesFile}.
- * @public
- */
-export declare const puzzlesFile: Converter<IPuzzlesFile>;
 /**
  * Loads an arbitrary JSON file and parses it to return a validated
- * {@link File.Model.IPuzzlesFile | IPuzzlesFile}.
+ * {@link Files.Model.IPuzzlesFile | IPuzzlesFile}.
  * @param path - String path to the file
  * @returns `Success` with the resulting file, or `Failure` with details if an
  * error occurs.
  * @public
  */
 export declare function loadJsonPuzzlesFileSync(path: string): Result<IPuzzlesFile>;
-//# sourceMappingURL=converters.d.ts.map
+//# sourceMappingURL=filesystem.d.ts.map

package/lib/packlets/{file/converters.js → files/filesystem.js}

@@ -2,7 +2,7 @@
 /*
  * MIT License
  *
- * Copyright (c) 2023 Erik Fortune
+ * Copyright (c) 2025 Erik Fortune
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -23,27 +23,18 @@
  * SOFTWARE.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.puzzlesFile = void 0;
 exports.loadJsonPuzzlesFileSync = loadJsonPuzzlesFileSync;
-const ts_utils_1 = require("@fgv/ts-utils");
+const converters_1 = require("./converters");
 const ts_json_base_1 = require("@fgv/ts-json-base");
-const common_1 = require("../common");
-/**
- * Converts an arbitrary object to a {@link File.Model.IPuzzlesFile | IPuzzlesFile}.
- * @public
- */
-exports.puzzlesFile = ts_utils_1.Converters.strictObject({
-    puzzles: ts_utils_1.Converters.arrayOf(common_1.Converters.puzzleDescription)
-});
 /**
  * Loads an arbitrary JSON file and parses it to return a validated
- * {@link File.Model.IPuzzlesFile | IPuzzlesFile}.
+ * {@link Files.Model.IPuzzlesFile | IPuzzlesFile}.
  * @param path - String path to the file
  * @returns `Success` with the resulting file, or `Failure` with details if an
  * error occurs.
  * @public
  */
 function loadJsonPuzzlesFileSync(path) {
-    return ts_json_base_1.JsonFile.convertJsonFileSync(path, exports.puzzlesFile);
+    return ts_json_base_1.JsonFile.convertJsonFileSync(path, converters_1.puzzlesFile);
 }
-//# sourceMappingURL=converters.js.map
+//# sourceMappingURL=filesystem.js.map

package/lib/packlets/files/index.d.ts

@@ -0,0 +1,5 @@
+import * as Converters from './converters';
+import * as Model from './model';
+import * as FileSystem from './filesystem';
+export { Converters, Model, FileSystem };
+//# sourceMappingURL=index.d.ts.map

package/lib/packlets/{file → files}/index.js

@@ -56,9 +56,11 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Model = exports.Converters = void 0;
+exports.FileSystem = exports.Model = exports.Converters = void 0;
 const Converters = __importStar(require("./converters"));
 exports.Converters = Converters;
 const Model = __importStar(require("./model"));
 exports.Model = Model;
+const FileSystem = __importStar(require("./filesystem"));
+exports.FileSystem = FileSystem;
 //# sourceMappingURL=index.js.map

package/lib/packlets/files/model.d.ts

@@ -0,0 +1,32 @@
+import { PuzzleType } from '../common';
+/**
+ * Dimensional configuration for puzzles
+ * @public
+ */
+export interface IPuzzleFileDimensions {
+    cageWidthInCells: number;
+    cageHeightInCells: number;
+    boardWidthInCages: number;
+    boardHeightInCages: number;
+}
+/**
+ * Input format for puzzle data in JSON files.
+ * Contains only the essential data needed to create an IPuzzleDefinition.
+ * @public
+ */
+export interface IPuzzleFileData {
+    id?: string;
+    description: string;
+    type: PuzzleType;
+    level: number;
+    cells: string;
+    dimensions: IPuzzleFileDimensions;
+}
+/**
+ * Parsed file containing a collection of puzzles.
+ * @public
+ */
+export interface IPuzzlesFile {
+    puzzles: IPuzzleFileData[];
+}
+//# sourceMappingURL=model.d.ts.map

package/lib/packlets/hints/baseHintProvider.d.ts

@@ -0,0 +1,103 @@
+import { Result } from '@fgv/ts-utils';
+import { CellId, Puzzle, PuzzleState } from '../common';
+import { IHintProvider } from './interfaces';
+import { ConfidenceLevel, DifficultyLevel, ExplanationLevel, ICellAction, IHint, IHintExplanation, IHintGenerationOptions, IRelevantCells, TechniqueId } from './types';
+/**
+ * Configuration for a {@link Hints.BaseHintProvider | BaseHintProvider} instance.
+ * @public
+ */
+export interface IBaseHintProviderConfig {
+    readonly techniqueId: TechniqueId;
+    readonly techniqueName: string;
+    readonly difficulty: DifficultyLevel;
+    readonly priority: number;
+    readonly defaultConfidence?: ConfidenceLevel;
+}
+/**
+ * Abstract base class providing common functionality for hint providers.
+ * @public
+ */
+export declare abstract class BaseHintProvider implements IHintProvider {
+    readonly techniqueId: TechniqueId;
+    readonly techniqueName: string;
+    readonly difficulty: DifficultyLevel;
+    readonly priority: number;
+    protected readonly defaultConfidence: ConfidenceLevel;
+    protected constructor(config: IBaseHintProviderConfig);
+    /**
+     * Abstract method to be implemented by concrete providers.
+     * Determines if this provider can potentially generate hints for the given puzzle.
+     */
+    abstract canProvideHints(puzzle: Puzzle, state: PuzzleState): boolean;
+    /**
+     * Abstract method to be implemented by concrete providers.
+     * Generates all possible hints using this technique for the given puzzle.
+     */
+    abstract generateHints(puzzle: Puzzle, state: PuzzleState, options?: IHintGenerationOptions): Result<readonly IHint[]>;
+    /**
+     * Utility method to create a hint with consistent structure.
+     * @param cellActions - The actions to be performed on cells
+     * @param relevantCells - The cells relevant to understanding the hint
+     * @param explanations - The explanations for the hint
+     * @param confidence - The confidence level for this hint
+     * @returns A complete hint object
+     */
+    protected createHint(cellActions: readonly ICellAction[], relevantCells: IRelevantCells, explanations: readonly IHintExplanation[], confidence?: ConfidenceLevel): IHint;
+    /**
+     * Utility method to create cell actions.
+     * @param cellId - The ID of the cell to act upon
+     * @param action - The type of action to perform
+     * @param value - Optional value for set-value actions
+     * @param reason - Optional reason for the action
+     * @returns A cell action object
+     */
+    protected createCellAction(cellId: CellId, action: ICellAction['action'], value?: number, reason?: string): ICellAction;
+    /**
+     * Utility method to create relevant cells grouping.
+     * @param primary - Primary cells that are the focus of the hint
+     * @param secondary - Secondary cells that provide context
+     * @param affected - Cells that will be affected by applying the hint
+     * @returns A relevant cells object
+     */
+    protected createRelevantCells(primary: readonly CellId[], secondary?: readonly CellId[], affected?: readonly CellId[]): IRelevantCells;
+    /**
+     * Utility method to create hint explanations.
+     * @param level - The level of detail for the explanation
+     * @param title - The title of the explanation
+     * @param description - The main description
+     * @param steps - Optional step-by-step instructions
+     * @param tips - Optional tips for understanding the technique
+     * @returns A hint explanation object
+     */
+    protected createExplanation(level: ExplanationLevel, title: string, description: string, steps?: readonly string[], tips?: readonly string[]): IHintExplanation;
+    /**
+     * Filters hints based on generation options.
+     * @param hints - The hints to filter
+     * @param options - The filtering options
+     * @returns Filtered array of hints
+     */
+    protected filterHints(hints: readonly IHint[], options?: IHintGenerationOptions): readonly IHint[];
+    /**
+     * Validates generation options for consistency.
+     * @param options - The options to validate
+     * @returns Result indicating validation success or failure
+     */
+    protected validateOptions(options?: IHintGenerationOptions): Result<void>;
+    /**
+     * Gets all empty cells in the puzzle.
+     * @param puzzle - The puzzle structure
+     * @param state - The puzzle state to analyze
+     * @returns Array of cell IDs that are empty
+     */
+    protected getEmptyCells(puzzle: Puzzle, state: PuzzleState): CellId[];
+    /**
+     * Gets the possible candidate values for a specific cell using cage-based constraints.
+     * This implementation works with any puzzle variant by checking all applicable cages.
+     * @param cellId - The cell to analyze
+     * @param puzzle - The puzzle structure containing constraints
+     * @param state - The current puzzle state
+     * @returns Array of possible values for the cell
+     */
+    protected getCandidates(cellId: CellId, puzzle: Puzzle, state: PuzzleState): number[];
+}
+//# sourceMappingURL=baseHintProvider.d.ts.map

package/lib/packlets/hints/baseHintProvider.js

@@ -0,0 +1,203 @@
+"use strict";
+/*
+ * MIT License
+ *
+ * Copyright (c) 2023 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseHintProvider = void 0;
+const ts_utils_1 = require("@fgv/ts-utils");
+const types_1 = require("./types");
+/**
+ * Abstract base class providing common functionality for hint providers.
+ * @public
+ */
+class BaseHintProvider {
+    constructor(config) {
+        var _a;
+        this.techniqueId = config.techniqueId;
+        this.techniqueName = config.techniqueName;
+        this.difficulty = config.difficulty;
+        this.priority = config.priority;
+        this.defaultConfidence = (_a = config.defaultConfidence) !== null && _a !== void 0 ? _a : types_1.ConfidenceLevels.MEDIUM;
+    }
+    /**
+     * Utility method to create a hint with consistent structure.
+     * @param cellActions - The actions to be performed on cells
+     * @param relevantCells - The cells relevant to understanding the hint
+     * @param explanations - The explanations for the hint
+     * @param confidence - The confidence level for this hint
+     * @returns A complete hint object
+     */
+    createHint(cellActions, relevantCells, explanations, confidence) {
+        /* c8 ignore next 1 - defense in depth */
+        confidence = confidence !== null && confidence !== void 0 ? confidence : this.defaultConfidence;
+        return {
+            techniqueId: this.techniqueId,
+            techniqueName: this.techniqueName,
+            difficulty: this.difficulty,
+            confidence,
+            cellActions,
+            relevantCells,
+            explanations,
+            priority: this.priority
+        };
+    }
+    /**
+     * Utility method to create cell actions.
+     * @param cellId - The ID of the cell to act upon
+     * @param action - The type of action to perform
+     * @param value - Optional value for set-value actions
+     * @param reason - Optional reason for the action
+     * @returns A cell action object
+     */
+    createCellAction(cellId, action, value, reason) {
+        return {
+            cellId,
+            action,
+            value,
+            reason
+        };
+    }
+    /**
+     * Utility method to create relevant cells grouping.
+     * @param primary - Primary cells that are the focus of the hint
+     * @param secondary - Secondary cells that provide context
+     * @param affected - Cells that will be affected by applying the hint
+     * @returns A relevant cells object
+     */
+    createRelevantCells(primary, secondary = [], affected = []) {
+        return {
+            primary,
+            secondary,
+            affected
+        };
+    }
+    /**
+     * Utility method to create hint explanations.
+     * @param level - The level of detail for the explanation
+     * @param title - The title of the explanation
+     * @param description - The main description
+     * @param steps - Optional step-by-step instructions
+     * @param tips - Optional tips for understanding the technique
+     * @returns A hint explanation object
+     */
+    createExplanation(level, title, description, steps, tips) {
+        return {
+            level,
+            title,
+            description,
+            steps,
+            tips
+        };
+    }
+    /**
+     * Filters hints based on generation options.
+     * @param hints - The hints to filter
+     * @param options - The filtering options
+     * @returns Filtered array of hints
+     */
+    filterHints(hints, options) {
+        if (!options) {
+            return hints;
+        }
+        let filtered = [...hints];
+        // Filter by minimum confidence
+        if (options.minConfidence) {
+            filtered = filtered.filter((hint) => hint.confidence >= options.minConfidence);
+        }
+        // Filter by enabled techniques
+        if (options.enabledTechniques && options.enabledTechniques.length > 0) {
+            filtered = filtered.filter((hint) => options.enabledTechniques.includes(hint.techniqueId));
+        }
+        // Limit number of hints
+        if (options.maxHints && options.maxHints > 0) {
+            // Sort by confidence (descending) then priority (ascending)
+            filtered.sort((a, b) => {
+                if (a.confidence !== b.confidence) {
+                    return b.confidence - a.confidence;
+                }
+                return a.priority - b.priority;
+            });
+            filtered = filtered.slice(0, options.maxHints);
+        }
+        return filtered;
+    }
+    /**
+     * Validates generation options for consistency.
+     * @param options - The options to validate
+     * @returns Result indicating validation success or failure
+     */
+    validateOptions(options) {
+        if (!options) {
+            return (0, ts_utils_1.succeed)(undefined);
+        }
+        if (options.maxHints !== undefined && options.maxHints < 0) {
+            return (0, ts_utils_1.fail)('maxHints cannot be negative');
+        }
+        if (options.minConfidence !== undefined && (options.minConfidence < 1 || options.minConfidence > 5)) {
+            return (0, ts_utils_1.fail)('minConfidence must be between 1 and 5');
+        }
+        return (0, ts_utils_1.succeed)(undefined);
+    }
+    /**
+     * Gets all empty cells in the puzzle.
+     * @param puzzle - The puzzle structure
+     * @param state - The puzzle state to analyze
+     * @returns Array of cell IDs that are empty
+     */
+    getEmptyCells(puzzle, state) {
+        return puzzle.getEmptyCells(state).map((cell) => cell.id);
+    }
+    /**
+     * Gets the possible candidate values for a specific cell using cage-based constraints.
+     * This implementation works with any puzzle variant by checking all applicable cages.
+     * @param cellId - The cell to analyze
+     * @param puzzle - The puzzle structure containing constraints
+     * @param state - The current puzzle state
+     * @returns Array of possible values for the cell
+     */
+    getCandidates(cellId, puzzle, state) {
+        if (state.hasValue(cellId)) {
+            return [];
+        }
+        // Get maximum value based on grid size (typically sqrt of total cells)
+        const maxValue = Math.sqrt(puzzle.numRows * puzzle.numColumns);
+        // Find all cages that contain this cell
+        const applicableCages = puzzle.cages.filter((cage) => cage.containsCell(cellId));
+        // Collect all values that are forbidden due to cage constraints
+        const usedValues = new Set();
+        for (const cage of applicableCages) {
+            const cageValues = cage.containedValues(state);
+            cageValues.forEach((value) => usedValues.add(value));
+        }
+        // Generate candidates (values not used in any applicable cage)
+        const candidates = [];
+        for (let value = 1; value <= maxValue; value++) {
+            if (!usedValues.has(value)) {
+                candidates.push(value);
+            }
+        }
+        return candidates;
+    }
+}
+exports.BaseHintProvider = BaseHintProvider;
+//# sourceMappingURL=baseHintProvider.js.map

package/lib/packlets/hints/explanations.d.ts

@@ -0,0 +1,105 @@
+import { Result } from '@fgv/ts-utils';
+import { Puzzle, PuzzleState } from '../common';
+import { IHintExplanationProvider } from './interfaces';
+import { ExplanationLevel, IHint, IHintExplanation, TechniqueId } from './types';
+/**
+ * Registry for managing hint explanation providers.
+ * @public
+ */
+export declare class ExplanationRegistry {
+    private readonly _providers;
+    /**
+     * Creates a new ExplanationRegistry instance.
+     */
+    constructor();
+    /**
+     * Registers a new explanation provider.
+     * @param provider - The provider to register
+     * @returns Result indicating success or failure of registration
+     */
+    registerProvider(provider: IHintExplanationProvider): Result<void>;
+    /**
+     * Gets explanations for a specific hint.
+     * @param hint - The hint to explain
+     * @param puzzle - The puzzle structure containing constraints
+     * @param state - The puzzle state context
+     * @returns Result containing the explanations
+     */
+    getExplanations(hint: IHint, puzzle: Puzzle, state: PuzzleState): Result<readonly IHintExplanation[]>;
+    /**
+     * Gets a specific explanation at the requested level.
+     * @param hint - The hint to explain
+     * @param level - The desired explanation level
+     * @param state - The puzzle state context
+     * @returns Result containing the explanation at the specified level
+     */
+    getExplanationAtLevel(hint: IHint, level: ExplanationLevel, puzzle: Puzzle, state: PuzzleState): Result<IHintExplanation>;
+}
+/**
+ * Utility class for formatting and displaying hint explanations.
+ * @public
+ */
+export declare class ExplanationFormatter {
+    /**
+     * Formats a hint explanation as a readable string.
+     * @param explanation - The explanation to format
+     * @param includeSteps - Whether to include step-by-step instructions
+     * @param includeTips - Whether to include tips
+     * @returns Formatted explanation string
+     */
+    static formatExplanation(explanation: IHintExplanation, includeSteps?: boolean, includeTips?: boolean): string;
+    /**
+     * Formats all explanations for a hint as a structured string.
+     * @param explanations - The explanations to format
+     * @returns Formatted explanations string
+     */
+    static formatAllExplanations(explanations: readonly IHintExplanation[]): string;
+    /**
+     * Creates a summary of available explanation levels.
+     * @param explanations - The explanations to summarize
+     * @returns Summary string
+     */
+    static createLevelSummary(explanations: readonly IHintExplanation[]): string;
+}
+/**
+ * Educational content manager for Sudoku solving techniques.
+ * @public
+ */
+export declare class EducationalContent {
+    private static readonly _techniqueIntroductions;
+    private static readonly _techniqueRelationships;
+    /**
+     * Gets an introduction to a specific technique.
+     * @param techniqueId - The technique to introduce
+     * @returns Result containing the introduction text
+     */
+    static getTechniqueIntroduction(techniqueId: TechniqueId): Result<string>;
+    /**
+     * Gets relationship information for a technique.
+     * @param techniqueId - The technique to get relationships for
+     * @returns Result containing the relationship information
+     */
+    static getTechniqueRelationships(techniqueId: TechniqueId): Result<readonly string[]>;
+    /**
+     * Gets a complete educational overview for a technique.
+     * @param techniqueId - The technique to describe
+     * @returns Result containing the complete overview
+     */
+    static getTechniqueOverview(techniqueId: TechniqueId): Result<string>;
+    /**
+     * Gets general Sudoku solving advice.
+     * @returns Array of general solving tips
+     */
+    static getGeneralSolvingTips(): readonly string[];
+    /**
+     * Gets difficulty progression advice.
+     * @returns Advice for progressing through difficulty levels
+     */
+    static getDifficultyProgression(): readonly string[];
+    /**
+     * Creates a complete educational guide for beginners.
+     * @returns Comprehensive beginner guide
+     */
+    static createBeginnerGuide(): string;
+}
+//# sourceMappingURL=explanations.d.ts.map