@logic-pad/core 0.26.2 → 0.26.3

package/dist/src/data/rules/cellCountRule.js

@@ -0,0 +1,138 @@
+import { ConfigType } from '../config.js';
+import GridData from '../grid.js';
+import { Color, State } from '../primitives.js';
+import AreaNumberSymbol from '../symbols/areaNumberSymbol.js';
+import Rule from './rule.js';
+export default class CellCountRule extends Rule {
+    color;
+    count;
+    title = 'Total Count';
+    static CONFIGS = Object.freeze([
+        {
+            type: ConfigType.Color,
+            default: Color.Light,
+            allowGray: false,
+            field: 'color',
+            description: 'Color',
+            configurable: true,
+        },
+        {
+            type: ConfigType.Number,
+            default: 10,
+            min: 0,
+            field: 'count',
+            description: 'Count',
+            configurable: true,
+        },
+    ]);
+    static EXAMPLE_GRID_LIGHT = Object.freeze([
+        GridData.create(['bbbbb', 'bbbbb', 'bbbbb', 'bbbbb']),
+        GridData.create(['bbbbb', 'bbbbb', 'bwbbb', 'bbbbb']).withSymbols([
+            new AreaNumberSymbol(1, 2, 1),
+        ]),
+        GridData.create(['bbbbb', 'bbbbb', 'bwwbb', 'bbbbb']).withSymbols([
+            new AreaNumberSymbol(1, 2, 2),
+        ]),
+        GridData.create(['bbbbb', 'bwbbb', 'bwwbb', 'bbbbb']).withSymbols([
+            new AreaNumberSymbol(1, 2, 3),
+        ]),
+        GridData.create(['bbbbb', 'bwwbb', 'bwwbb', 'bbbbb']).withSymbols([
+            new AreaNumberSymbol(1, 2, 4),
+        ]),
+        GridData.create(['bbbbb', 'bwwbb', 'bwwwb', 'bbbbb']).withSymbols([
+            new AreaNumberSymbol(1, 2, 5),
+        ]),
+        GridData.create(['bbbbb', 'bwwwb', 'bwwwb', 'bbbbb']).withSymbols([
+            new AreaNumberSymbol(1, 2, 6),
+        ]),
+        GridData.create(['bbbbb', 'bbbbb', 'wwwbb', 'wwwwb']).withSymbols([
+            new AreaNumberSymbol(1, 2, 7),
+        ]),
+        GridData.create(['bbbbb', 'wbbbb', 'wwwbb', 'wwwwb']).withSymbols([
+            new AreaNumberSymbol(1, 2, 8),
+        ]),
+        GridData.create(['bbbbb', 'wwbbb', 'wwwbb', 'wwwwb']).withSymbols([
+            new AreaNumberSymbol(1, 2, 9),
+        ]),
+        GridData.create(['wbbbb', 'wwbbb', 'wwwbb', 'wwwwb']).withSymbols([
+            new AreaNumberSymbol(1, 2, 10),
+        ]),
+    ]);
+    static EXAMPLE_GRID_DARK = Object.freeze(CellCountRule.EXAMPLE_GRID_LIGHT.map(grid => grid.withTiles(tiles => tiles.map(row => row.map(tile => tile.withColor(tile.color === Color.Dark ? Color.Light : Color.Dark))))));
+    static SEARCH_VARIANTS = [
+        new CellCountRule(Color.Light, 10).searchVariant(),
+        new CellCountRule(Color.Dark, 10).searchVariant(),
+    ];
+    /**
+     * **There are <count> <color> cells in total**
+     *
+     * @param color - The color of the cells to count.
+     * @param count - The total number of cells of the given color.
+     */
+    constructor(color, count) {
+        super();
+        this.color = color;
+        this.count = count;
+        this.color = color;
+        this.count = count;
+    }
+    get id() {
+        return `cell_count`;
+    }
+    get explanation() {
+        return `There ${this.count === 1 ? 'is' : 'are'} ${this.count} ${this.color} cell${this.count === 1 ? '' : 's'} *in total*`;
+    }
+    get configs() {
+        return CellCountRule.CONFIGS;
+    }
+    createExampleGrid() {
+        if (this.count < CellCountRule.EXAMPLE_GRID_LIGHT.length) {
+            if (this.color === Color.Light) {
+                return CellCountRule.EXAMPLE_GRID_LIGHT[this.count];
+            }
+            else {
+                return CellCountRule.EXAMPLE_GRID_DARK[this.count];
+            }
+        }
+        else {
+            const grid = this.color === Color.Light
+                ? GridData.create(['wbbbb', 'wwbbb', 'wwwbb', 'wwwwb'])
+                : GridData.create(['bwwww', 'bbwww', 'bbbww', 'bbbbw']);
+            return grid.addSymbol(new AreaNumberSymbol(1, 2, this.count));
+        }
+    }
+    get searchVariants() {
+        return CellCountRule.SEARCH_VARIANTS;
+    }
+    validateGrid(grid) {
+        let colored = 0;
+        let possible = 0;
+        grid.forEach(tile => {
+            if (!tile.exists)
+                return;
+            if (tile.color === this.color)
+                colored++;
+            if (tile.color === Color.Gray)
+                possible++;
+        });
+        if (colored > this.count || colored + possible < this.count) {
+            return { state: State.Error, positions: [] };
+        }
+        else if (colored === this.count && possible === 0) {
+            return { state: State.Satisfied };
+        }
+        else {
+            return { state: State.Incomplete };
+        }
+    }
+    copyWith({ color, count }) {
+        return new CellCountRule(color ?? this.color, count ?? this.count);
+    }
+    withColor(color) {
+        return this.copyWith({ color });
+    }
+    withCount(count) {
+        return this.copyWith({ count });
+    }
+}
+export const instance = new CellCountRule(Color.Dark, 10);

package/dist/src/data/rules/completePatternRule.d.ts

@@ -0,0 +1,24 @@
+import GridData from '../grid.js';
+import { RuleState } from '../primitives.js';
+import Rule, { SearchVariant } from './rule.js';
+export default class CompletePatternRule extends Rule {
+    readonly title = "Complete The Pattern";
+    get configExplanation(): string;
+    private static readonly EXAMPLE_GRID;
+    private static readonly SEARCH_VARIANTS;
+    /**
+     * **Complete the pattern**
+     *
+     * This rule validates answers based on the provided solution.
+     */
+    constructor();
+    get id(): string;
+    get explanation(): string;
+    createExampleGrid(): GridData;
+    get searchVariants(): SearchVariant[];
+    validateGrid(_grid: GridData): RuleState;
+    copyWith(_: object): this;
+    get validateWithSolution(): boolean;
+    get isSingleton(): boolean;
+}
+export declare const instance: CompletePatternRule;

package/dist/src/data/rules/completePatternRule.js

@@ -0,0 +1,46 @@
+import GridData from '../grid.js';
+import { MajorRule, State } from '../primitives.js';
+import Rule from './rule.js';
+export default class CompletePatternRule extends Rule {
+    title = 'Complete The Pattern';
+    get configExplanation() {
+        return 'Complete the grid by pattern recognition. Your provided solution may override auto-validation.';
+    }
+    static EXAMPLE_GRID = Object.freeze(GridData.create(['wbwbw', 'bwbwb', 'wbwbw', 'bwbwb']));
+    static SEARCH_VARIANTS = [
+        new CompletePatternRule().searchVariant(),
+    ];
+    /**
+     * **Complete the pattern**
+     *
+     * This rule validates answers based on the provided solution.
+     */
+    constructor() {
+        super();
+    }
+    get id() {
+        return MajorRule.CompletePattern;
+    }
+    get explanation() {
+        return `Complete the pattern`;
+    }
+    createExampleGrid() {
+        return CompletePatternRule.EXAMPLE_GRID;
+    }
+    get searchVariants() {
+        return CompletePatternRule.SEARCH_VARIANTS;
+    }
+    validateGrid(_grid) {
+        return { state: State.Incomplete };
+    }
+    copyWith(_) {
+        return new CompletePatternRule();
+    }
+    get validateWithSolution() {
+        return true;
+    }
+    get isSingleton() {
+        return true;
+    }
+}
+export const instance = new CompletePatternRule();

package/dist/src/data/rules/connectAllRule.d.ts

@@ -0,0 +1,29 @@
+import { AnyConfig } from '../config.js';
+import GridData from '../grid.js';
+import { Color, RuleState } from '../primitives.js';
+import Rule, { SearchVariant } from './rule.js';
+export default class ConnectAllRule extends Rule {
+    readonly color: Color;
+    readonly title = "Connect All";
+    private static readonly CONFIGS;
+    private static readonly EXAMPLE_GRID_LIGHT;
+    private static readonly EXAMPLE_GRID_DARK;
+    private static readonly SEARCH_VARIANTS;
+    /**
+     * **Connect all <color> cells**
+     *
+     * @param color - The color of the cells to connect.
+     */
+    constructor(color: Color);
+    get id(): string;
+    get explanation(): string;
+    get configs(): readonly AnyConfig[] | null;
+    createExampleGrid(): GridData;
+    get searchVariants(): SearchVariant[];
+    validateGrid(grid: GridData): RuleState;
+    copyWith({ color }: {
+        color?: Color;
+    }): this;
+    withColor(color: Color): this;
+}
+export declare const instance: ConnectAllRule;

package/dist/src/data/rules/connectAllRule.js

@@ -0,0 +1,88 @@
+import { ConfigType } from '../config.js';
+import GridData from '../grid.js';
+import { array, minBy } from '../dataHelper.js';
+import { Color, State } from '../primitives.js';
+import Rule from './rule.js';
+export default class ConnectAllRule extends Rule {
+    color;
+    title = 'Connect All';
+    static CONFIGS = Object.freeze([
+        {
+            type: ConfigType.Color,
+            default: Color.Light,
+            allowGray: false,
+            field: 'color',
+            description: 'Color',
+            configurable: true,
+        },
+    ]);
+    static EXAMPLE_GRID_LIGHT = Object.freeze(GridData.create(['bwwwb', 'bwbww', 'wwwbb', 'wbwww']));
+    static EXAMPLE_GRID_DARK = Object.freeze(GridData.create(['wbbbw', 'wbwbb', 'bbbww', 'bwbbb']));
+    static SEARCH_VARIANTS = [
+        new ConnectAllRule(Color.Light).searchVariant(),
+        new ConnectAllRule(Color.Dark).searchVariant(),
+    ];
+    /**
+     * **Connect all <color> cells**
+     *
+     * @param color - The color of the cells to connect.
+     */
+    constructor(color) {
+        super();
+        this.color = color;
+        this.color = color;
+    }
+    get id() {
+        return `connect_all`;
+    }
+    get explanation() {
+        return `Connect all ${this.color} cells`;
+    }
+    get configs() {
+        return ConnectAllRule.CONFIGS;
+    }
+    createExampleGrid() {
+        return this.color === Color.Light
+            ? ConnectAllRule.EXAMPLE_GRID_LIGHT
+            : ConnectAllRule.EXAMPLE_GRID_DARK;
+    }
+    get searchVariants() {
+        return ConnectAllRule.SEARCH_VARIANTS;
+    }
+    validateGrid(grid) {
+        let complete = true;
+        const visited = array(grid.width, grid.height, (i, j) => !grid.getTile(i, j).exists);
+        const islands = [];
+        while (true) {
+            const seed = grid.find((tile, x, y) => !visited[y][x] && tile.color === this.color);
+            if (!seed)
+                break;
+            const positions = [];
+            grid.iterateArea(seed, tile => tile.color === this.color || tile.color === Color.Gray, (tile, x, y) => {
+                if (tile.color === Color.Gray)
+                    complete = false;
+                positions.push({ x, y });
+            }, visited);
+            islands.push(positions);
+        }
+        if (islands.length > 1) {
+            return {
+                state: State.Error,
+                positions: minBy(islands, island => island.length),
+            };
+        }
+        else if (islands.length <= 1) {
+            return { state: complete ? State.Satisfied : State.Incomplete };
+        }
+        else {
+            return { state: State.Incomplete }; // not reachable but the TS is not happy
+        }
+    }
+    copyWith({ color }) {
+        return new ConnectAllRule(color ?? this.color);
+    }
+    withColor(color) {
+        return this.copyWith({ color });
+    }
+}
+export const instance = new ConnectAllRule(Color.Dark);

package/dist/src/data/rules/connectZonesRule.d.ts

@@ -0,0 +1,29 @@
+import { AnyConfig } from '../config.js';
+import GridData from '../grid.js';
+import { Color, RuleState } from '../primitives.js';
+import Rule, { SearchVariant } from './rule.js';
+export default class ConnectZonesRule extends Rule {
+    readonly color: Color;
+    readonly title = "Connect Zones";
+    private static readonly CONFIGS;
+    private static readonly EXAMPLE_GRID_LIGHT;
+    private static readonly EXAMPLE_GRID_DARK;
+    private static readonly SEARCH_VARIANTS;
+    /**
+     * **Connect all <color> cells in each zone**
+     *
+     * @param color - The color of the cells to connect.
+     */
+    constructor(color: Color);
+    get id(): string;
+    get explanation(): string;
+    get configs(): readonly AnyConfig[] | null;
+    createExampleGrid(): GridData;
+    get searchVariants(): SearchVariant[];
+    validateGrid(grid: GridData): RuleState;
+    copyWith({ color }: {
+        color?: Color;
+    }): this;
+    withColor(color: Color): this;
+}
+export declare const instance: ConnectZonesRule;

package/dist/src/data/rules/connectZonesRule.js

@@ -0,0 +1,111 @@
+import { ConfigType } from '../config.js';
+import GridData from '../grid.js';
+import { array, minBy } from '../dataHelper.js';
+import { Color, State } from '../primitives.js';
+import Rule from './rule.js';
+import GridZones from '../gridZones.js';
+export default class ConnectZonesRule extends Rule {
+    color;
+    title = 'Connect Zones';
+    static CONFIGS = Object.freeze([
+        {
+            type: ConfigType.Color,
+            default: Color.Light,
+            allowGray: false,
+            field: 'color',
+            description: 'Color',
+            configurable: true,
+        },
+    ]);
+    static EXAMPLE_GRID_LIGHT = Object.freeze(GridData.create(['wbbwb', 'wbbwb', 'wbbww', 'wwbbb'])
+        .withZones(new GridZones([
+        { x1: 2, y1: 1, x2: 2, y2: 2 },
+        { x1: 1, y1: 0, x2: 2, y2: 0 },
+        { x1: 1, y1: 1, x2: 2, y2: 1 },
+        { x1: 2, y1: 2, x2: 3, y2: 2 },
+        { x1: 2, y1: 3, x2: 3, y2: 3 },
+    ]))
+        .addRule(new ConnectZonesRule(Color.Light)));
+    static EXAMPLE_GRID_DARK = Object.freeze(ConnectZonesRule.EXAMPLE_GRID_LIGHT.withTiles(tiles => tiles.map(row => row.map(tile => tile.withColor(tile.color === Color.Dark ? Color.Light : Color.Dark)))));
+    static SEARCH_VARIANTS = [
+        new ConnectZonesRule(Color.Light).searchVariant(),
+        new ConnectZonesRule(Color.Dark).searchVariant(),
+    ];
+    /**
+     * **Connect all <color> cells in each zone**
+     *
+     * @param color - The color of the cells to connect.
+     */
+    constructor(color) {
+        super();
+        this.color = color;
+        this.color = color;
+    }
+    get id() {
+        return `connect_zones`;
+    }
+    get explanation() {
+        return `Connect all ${this.color} cells in each zone`;
+    }
+    get configs() {
+        return ConnectZonesRule.CONFIGS;
+    }
+    createExampleGrid() {
+        return this.color === Color.Light
+            ? ConnectZonesRule.EXAMPLE_GRID_LIGHT
+            : ConnectZonesRule.EXAMPLE_GRID_DARK;
+    }
+    get searchVariants() {
+        return ConnectZonesRule.SEARCH_VARIANTS;
+    }
+    validateGrid(grid) {
+        let complete = true;
+        let zoneId = 1;
+        const zoneMap = array(grid.width, grid.height, () => 0);
+        const visited = array(grid.width, grid.height, (i, j) => !grid.getTile(i, j).exists);
+        const zones = grid.reduceByZone((zone, tile, x, y) => {
+            zoneMap[y][x] = zone;
+            if (tile.exists && tile.color === Color.Gray) {
+                complete = false;
+            }
+            return zone;
+        }, () => zoneId++);
+        for (const zone of zones) {
+            const islands = [];
+            while (true) {
+                const seed = grid.find((tile, x, y) => !visited[y][x] &&
+                    zoneMap[y][x] === zone &&
+                    tile.color === this.color);
+                if (!seed)
+                    break;
+                const positions = [];
+                grid.iterateArea(seed, (tile, x, y) => {
+                    if (tile.color !== this.color && tile.color !== Color.Gray) {
+                        return false;
+                    }
+                    const pos = grid.toArrayCoordinates(x, y);
+                    return zoneMap[pos.y][pos.x] === zone;
+                }, (tile, x, y) => {
+                    if (tile.color === Color.Gray)
+                        complete = false;
+                    positions.push({ x, y });
+                }, visited);
+                islands.push(positions);
+            }
+            if (islands.length > 1) {
+                return {
+                    state: State.Error,
+                    positions: minBy(islands, island => island.length),
+                };
+            }
+        }
+        return { state: complete ? State.Satisfied : State.Incomplete };
+    }
+    copyWith({ color }) {
+        return new ConnectZonesRule(color ?? this.color);
+    }
+    withColor(color) {
+        return this.copyWith({ color });
+    }
+}
+export const instance = new ConnectZonesRule(Color.Dark);

package/dist/src/data/rules/containsShapeRule.d.ts

@@ -0,0 +1,34 @@
+import { AnyConfig } from '../config.js';
+import GridData from '../grid.js';
+import { Color, RuleState } from '../primitives.js';
+import { Shape } from '../shapes.js';
+import RegionShapeRule from './regionShapeRule.js';
+import { SearchVariant } from './rule.js';
+export default class ContainsShapeRule extends RegionShapeRule {
+    readonly title = "Areas Contain Pattern";
+    private static readonly EXAMPLE_GRID_LIGHT;
+    private static readonly EXAMPLE_GRID_DARK;
+    private static readonly CONFIGS;
+    private static readonly SEARCH_VARIANTS;
+    readonly pattern: GridData;
+    readonly cache: Shape[];
+    /**
+     * **All <color> areas must contain this pattern**
+     *
+     * @param color - The color of the regions to compare.
+     * @param pattern - GridData representing the required pattern. Only non-gray tiles are considered.
+     */
+    constructor(color: Color, pattern: GridData);
+    get id(): string;
+    get explanation(): string;
+    get configs(): readonly AnyConfig[] | null;
+    createExampleGrid(): GridData;
+    get searchVariants(): SearchVariant[];
+    validateGrid(grid: GridData): RuleState;
+    copyWith({ color, pattern, }: {
+        color?: Color;
+        pattern?: GridData;
+    }): this;
+    withPattern(pattern: GridData): this;
+}
+export declare const instance: ContainsShapeRule;

package/dist/src/data/rules/containsShapeRule.js

@@ -0,0 +1,125 @@
+import { ConfigType } from '../config.js';
+import { array } from '../dataHelper.js';
+import GridData from '../grid.js';
+import { Color, State } from '../primitives.js';
+import { getShapeVariants, sanitizePatternGrid, tilesToShape, } from '../shapes.js';
+import RegionShapeRule from './regionShapeRule.js';
+export default class ContainsShapeRule extends RegionShapeRule {
+    title = 'Areas Contain Pattern';
+    static EXAMPLE_GRID_LIGHT = Object.freeze(GridData.create(['nnnnn', 'nnnnn', 'wwwwn', 'nnnnn', 'nnnnn']));
+    static EXAMPLE_GRID_DARK = Object.freeze(GridData.create(['nnnnn', 'nnnnn', 'bbbbn', 'nnnnn', 'nnnnn']));
+    static CONFIGS = Object.freeze([
+        {
+            type: ConfigType.Color,
+            default: Color.Light,
+            allowGray: false,
+            field: 'color',
+            description: 'Color',
+            configurable: true,
+        },
+        {
+            type: ConfigType.Shape,
+            default: ContainsShapeRule.EXAMPLE_GRID_LIGHT,
+            resizable: true,
+            field: 'pattern',
+            description: 'Pattern',
+            explanation: 'The pattern to be contained. Must only include tiles of the selected color.',
+            configurable: true,
+        },
+    ]);
+    static SEARCH_VARIANTS = [
+        new ContainsShapeRule(Color.Light, ContainsShapeRule.EXAMPLE_GRID_LIGHT).searchVariant(),
+        new ContainsShapeRule(Color.Dark, ContainsShapeRule.EXAMPLE_GRID_DARK).searchVariant(),
+    ];
+    pattern;
+    cache;
+    /**
+     * **All <color> areas must contain this pattern**
+     *
+     * @param color - The color of the regions to compare.
+     * @param pattern - GridData representing the required pattern. Only non-gray tiles are considered.
+     */
+    constructor(color, pattern) {
+        super(color);
+        this.pattern = sanitizePatternGrid(pattern, t => t.color === color ? t : t.withColor(Color.Gray));
+        this.cache = getShapeVariants(tilesToShape(this.pattern.tiles));
+    }
+    get id() {
+        return `contains_shape`;
+    }
+    get explanation() {
+        return `All ${this.color} areas must contain this pattern`;
+    }
+    get configs() {
+        return ContainsShapeRule.CONFIGS;
+    }
+    createExampleGrid() {
+        let minX = Number.POSITIVE_INFINITY;
+        let minY = Number.POSITIVE_INFINITY;
+        let maxX = Number.NEGATIVE_INFINITY;
+        let maxY = Number.NEGATIVE_INFINITY;
+        this.pattern.forEach((tile, x, y) => {
+            if (tile.color !== Color.Gray && tile.exists) {
+                minX = Math.min(minX, x);
+                minY = Math.min(minY, y);
+                maxX = Math.max(maxX, x);
+                maxY = Math.max(maxY, y);
+            }
+        });
+        const width = maxX - minX + 1;
+        const height = maxY - minY + 1;
+        if (!Number.isFinite(width) || !Number.isFinite(height)) {
+            return GridData.create(0, 0);
+        }
+        const tiles = array(width, height, (x, y) => {
+            const tile = this.pattern.getTile(x + minX, y + minY);
+            if (!tile.exists || tile.color !== Color.Gray)
+                return tile;
+            return tile.withExists(false);
+        });
+        return GridData.create(width, height, tiles);
+    }
+    get searchVariants() {
+        return ContainsShapeRule.SEARCH_VARIANTS;
+    }
+    validateGrid(grid) {
+        const { regions, complete } = this.getShapeRegions(grid);
+        const errorRegion = regions.find(r => {
+            for (const pattern of this.cache) {
+                if (r.shape.elements.length < pattern.elements.length)
+                    continue;
+                for (let y = 0; y <= r.shape.height - pattern.height; y++) {
+                    for (let x = 0; x <= r.shape.width - pattern.width; x++) {
+                        let match = true;
+                        for (const element of pattern.elements) {
+                            const tile = r.shape.elements.find(e => e.x === x + element.x && e.y === y + element.y);
+                            if (!tile || tile.color !== element.color) {
+                                match = false;
+                                break;
+                            }
+                        }
+                        if (match)
+                            return false;
+                    }
+                }
+            }
+            return true;
+        });
+        if (errorRegion) {
+            return {
+                state: State.Error,
+                positions: errorRegion.positions,
+            };
+        }
+        else {
+            return { state: complete ? State.Satisfied : State.Incomplete };
+        }
+    }
+    copyWith({ color, pattern, }) {
+        return new ContainsShapeRule(color ?? this.color, pattern ?? this.pattern);
+    }
+    withPattern(pattern) {
+        return this.copyWith({ pattern });
+    }
+}
+export const instance = new ContainsShapeRule(Color.Dark, GridData.create([]));

package/dist/src/data/rules/customRule.d.ts

@@ -0,0 +1,34 @@
+import { AnyConfig } from '../config.js';
+import GridData from '../grid.js';
+import { RuleState } from '../primitives.js';
+import Rule, { SearchVariant } from './rule.js';
+export default class CustomRule extends Rule {
+    readonly description: string;
+    readonly grid: GridData;
+    readonly title = "Custom Rule";
+    get configExplanation(): string;
+    private static readonly EXAMPLE_GRID;
+    static readonly configs: readonly AnyConfig[];
+    private static readonly SEARCH_VARIANTS;
+    /**
+     * A custom rule with a description and thumbnail grid.
+     *
+     * This rule validates answers based on the provided solution.
+     *
+     * @param description - The description of the rule.
+     * @param grid - The thumbnail grid of the rule, preferably 5x4 in size.
+     */
+    constructor(description: string, grid: GridData);
+    get id(): string;
+    get explanation(): string;
+    get configs(): readonly AnyConfig[] | null;
+    createExampleGrid(): GridData;
+    get searchVariants(): SearchVariant[];
+    validateGrid(_grid: GridData): RuleState;
+    copyWith({ description, grid, }: {
+        description?: string;
+        grid?: GridData;
+    }): this;
+    get validateWithSolution(): boolean;
+}
+export declare const instance: CustomRule;