cubing 0.25.13 → 0.26.1

package/dist/types/Alg-6f3dc52c.d.ts

@@ -0,0 +1,278 @@
+declare enum IterationDirection {
+    Forwards = 1,
+    Backwards = -1
+}
+declare function direct<T>(g: Iterable<T>, iterDir: IterationDirection): Iterable<T>;
+declare function directedGenerator<T>(g: Generator<T>, direction: IterationDirection): Generator<T>;
+
+interface QuantumMoveModifications {
+    outerLayer?: number;
+    innerLayer?: number;
+    family?: string;
+}
+declare class QuantumMove extends Comparable {
+    #private;
+    constructor(family: string, innerLayer?: number | null, outerLayer?: number | null);
+    static fromString(s: string): QuantumMove;
+    modified(modifications: QuantumMoveModifications): QuantumMove;
+    isIdentical(other: QuantumMove): boolean;
+    /** @deprecated */
+    get family(): string;
+    /** @deprecated */
+    get outerLayer(): number | null;
+    /** @deprecated */
+    get innerLayer(): number | null;
+    experimentalExpand(): Generator<LeafUnit>;
+    toString(): string;
+}
+interface MoveModifications {
+    outerLayer?: number;
+    innerLayer?: number;
+    family?: string;
+    amount?: number;
+}
+declare class Move extends AlgCommon<Move> {
+    #private;
+    constructor(...args: [QuantumMove] | [QuantumMove, number] | [string] | [string, number]);
+    isIdentical(other: Comparable): boolean;
+    invert(): Move;
+    experimentalExpand(iterDir?: IterationDirection): Generator<LeafUnit>;
+    get quantum(): QuantumMove;
+    modified(modifications: MoveModifications): Move;
+    static fromString(s: string): Move;
+    get amount(): number;
+    /** @deprecated */
+    get type(): string;
+    /** @deprecated */
+    get family(): string;
+    /** @deprecated */
+    get outerLayer(): number | undefined;
+    /** @deprecated */
+    get innerLayer(): number | undefined;
+    toString(): string;
+}
+
+declare class Grouping extends AlgCommon<Grouping> {
+    #private;
+    constructor(algSource: FlexibleAlgSource, amount?: number);
+    isIdentical(other: Comparable): boolean;
+    get alg(): Alg;
+    get amount(): number;
+    /** @deprecated */
+    get experimentalRepetitionSuffix(): string;
+    invert(): Grouping;
+    experimentalExpand(iterDir?: IterationDirection, depth?: number): Generator<LeafUnit>;
+    static fromString(): Grouping;
+    toString(): string;
+    experimentalAsSquare1Tuple(): [moveU: Move, moveD: Move] | null;
+}
+
+declare class LineComment extends AlgCommon<LineComment> {
+    #private;
+    constructor(commentText: string);
+    get text(): string;
+    isIdentical(other: Comparable): boolean;
+    invert(): LineComment;
+    experimentalExpand(_iterDir?: IterationDirection, _depth?: number): Generator<LeafUnit>;
+    toString(): string;
+}
+
+declare class Commutator extends AlgCommon<Commutator> {
+    #private;
+    constructor(aSource: FlexibleAlgSource, bSource: FlexibleAlgSource);
+    get A(): Alg;
+    get B(): Alg;
+    isIdentical(other: Comparable): boolean;
+    invert(): Commutator;
+    experimentalExpand(iterDir?: IterationDirection, depth?: number): Generator<LeafUnit>;
+    toString(): string;
+}
+
+declare class Conjugate extends AlgCommon<Conjugate> {
+    #private;
+    constructor(aSource: FlexibleAlgSource, bSource: FlexibleAlgSource);
+    get A(): Alg;
+    get B(): Alg;
+    isIdentical(other: Comparable): boolean;
+    invert(): Conjugate;
+    experimentalExpand(iterDir: IterationDirection, depth?: number): Generator<LeafUnit>;
+    toString(): string;
+}
+
+declare class Newline extends AlgCommon<Newline> {
+    toString(): string;
+    isIdentical(other: Comparable): boolean;
+    invert(): Newline;
+    experimentalExpand(_iterDir?: IterationDirection, _depth?: number): Generator<LeafUnit>;
+}
+
+declare class Pause extends AlgCommon<Pause> {
+    toString(): string;
+    isIdentical(other: Comparable): boolean;
+    invert(): Pause;
+    experimentalExpand(_iterDir?: IterationDirection, _depth?: number): Generator<LeafUnit>;
+}
+
+declare type LeafUnit = Move | LineComment | Newline | Pause;
+declare type Unit = LeafUnit | Grouping | Conjugate | Commutator;
+
+declare abstract class Comparable {
+    is(c: any): boolean;
+    as<T>(c: new (...args: any) => T): T | null;
+    abstract isIdentical(other: Comparable): boolean;
+}
+interface Repeatable extends Comparable {
+    experimentalExpand(iterDir?: IterationDirection, depth?: number): Generator<LeafUnit>;
+}
+declare abstract class AlgCommon<T extends Alg | Unit> extends Comparable implements Repeatable {
+    constructor();
+    get log(): (message?: any) => void;
+    abstract toString(): string;
+    abstract invert(): T;
+    abstract experimentalExpand(iterDir: IterationDirection): Generator<LeafUnit>;
+}
+
+declare abstract class TraversalDownUp<DataDown, DataAlgUp, DataUnitUp = DataAlgUp> {
+    traverseUnit(unit: Unit, dataDown: DataDown): DataUnitUp;
+    traverseIntoUnit(unit: Unit, dataDown: DataDown): Unit;
+    abstract traverseAlg(alg: Alg, dataDown: DataDown): DataAlgUp;
+    abstract traverseGrouping(grouping: Grouping, dataDown: DataDown): DataUnitUp;
+    abstract traverseMove(move: Move, dataDown: DataDown): DataUnitUp;
+    abstract traverseCommutator(commutator: Commutator, dataDown: DataDown): DataUnitUp;
+    abstract traverseConjugate(conjugate: Conjugate, dataDown: DataDown): DataUnitUp;
+    abstract traversePause(pause: Pause, dataDown: DataDown): DataUnitUp;
+    abstract traverseNewline(newline: Newline, dataDown: DataDown): DataUnitUp;
+    abstract traverseLineComment(comment: LineComment, dataDown: DataDown): DataUnitUp;
+}
+declare abstract class TraversalUp<DataAlgUp, DataUnitUp = DataAlgUp> extends TraversalDownUp<undefined, DataAlgUp, DataUnitUp> {
+    traverseUnit(unit: Unit): DataUnitUp;
+    traverseIntoUnit(unit: Unit): Unit;
+    abstract traverseAlg(alg: Alg): DataAlgUp;
+    abstract traverseGrouping(grouping: Grouping): DataUnitUp;
+    abstract traverseMove(move: Move): DataUnitUp;
+    abstract traverseCommutator(commutator: Commutator): DataUnitUp;
+    abstract traverseConjugate(conjugate: Conjugate): DataUnitUp;
+    abstract traversePause(pause: Pause): DataUnitUp;
+    abstract traverseNewline(newline: Newline): DataUnitUp;
+    abstract traverseLineComment(comment: LineComment): DataUnitUp;
+}
+interface SimplifyOptions {
+    collapseMoves?: boolean;
+    quantumMoveOrder?: (quantumMove: QuantumMove) => number;
+    depth?: number | null;
+}
+
+declare type FlexibleAlgSource = string | Iterable<Unit> | Alg;
+/**
+ * Alg is a class that encapsulated a structured alg. To create an alg from a string, use:
+ *
+ *     new Alg("R U R'"); // Convenient
+ *     Alg.fromString(dynamicString); // Recommended when handling dynamic input.
+ *
+ * Once you have an Alg, you can call methods to transform it:
+ *
+ *     new Alg("[[R: U], R U R2']").expand().simplify().invert();
+ *
+ * To convert an Alg to a string, use .toString():
+ *
+ *     new Alg("R U F").invert().toString();
+ *
+ * If you need to debug, you may also find it convenient to use .log():
+ *
+ *     if (alg.isIdentical(alg.invert())) {
+ *       alg.log("A self-inverse!")
+ *     }
+ *
+ * For more information, see: {@link https://js.cubing.net/cubing/alg/}
+ *
+ */
+declare class Alg extends AlgCommon<Alg> {
+    #private;
+    constructor(alg?: FlexibleAlgSource);
+    /**
+     * Checks whether this Alg is structurally identical to another Alg. This
+     * essentially means that they are written identically apart from whitespace.
+     *
+     *     const alg1 = new Alg("R U L'");
+     *     const alg2 = new Alg("L U' R'").invert();
+     *     // true
+     *     alg1.isIdentical(alg2);
+     *
+     *     // false
+     *     new Alg("[R, U]").isIdentical(new Alg("R U R' U'"));
+     *     // true
+     *     new Alg("[R, U]").expand().isIdentical(new Alg("R U R' U'"));
+     *
+     * Note that .isIdentical() efficiently compares algorithms, but mainly exists
+     * to help optimize code when the structure of an algorithm hasn't changed.
+     * There are many ways to write the "same" alg on most puzzles, but is
+     * *highly* recommended to avoid expanding two Alg instances to compare them,
+     * since that can easily slow your program to a crawl if someone inputs an alg
+     * containing a large repetition. In general, you should use `cubing/kpuzzle`
+     * to compare if two algs have the same effect on a puzzle.
+     *
+     * Also note that parser annotations are not take into account while comparing
+     * algs:
+     *
+     *     const alg = new Alg([new Move("R"), new Move("U2")]);
+     *     // true, even though one of the algs has parser annotations
+     *     alg.isIdentical(new Alg("R U2"))
+     *
+     */
+    isIdentical(other: Comparable): boolean;
+    /**
+     * Returns the inverse of the given alg.
+     *
+     * Note that that this does not make any assumptions about what puzzle the alg
+     * is for. For example, U2 is its own inverse on a cube, but U2' has the same
+     * effect U3 (and not U2) on Megaminx:
+     *
+     *     // Outputs: R U2' L'
+     *     new Alg("L U2 R'").invert().log();
+     */
+    invert(): Alg;
+    /** @deprecated Use {@link Alg.expand} instead. */
+    experimentalExpand(iterDir?: IterationDirection, depth?: number): Generator<LeafUnit>;
+    /**
+     * Expands all Grouping, Commutator, and Conjugate parts nested inside the
+     * alg.
+     *
+     *     // F R U R' U' F'
+     *     new Alg("[F: [R, U]]").expand().log();
+     *
+     *     // F [R, U] F'
+     *     new Alg("[F: [R, U]]").expand(({ depth: 1 }).log();
+     *
+     * Avoid calling this on a user-provided alg unless the user explicitly asks
+     * to see the expanded alg. Otherwise, it's easy to make your program freeze
+     * when someone passes in an alg like: (R U)10000000
+     *
+     * Generally, if you want to perform an operation on an entire alg, you'll
+     * want to use something based on the `Traversal` mechanism, like countMoves()
+     * from `cubing/notation`.
+     */
+    expand(options?: {
+        depth?: number;
+    }): Alg;
+    /** @deprecated */
+    experimentalLeafMoves(): Generator<Move>;
+    concat(input: FlexibleAlgSource): Alg;
+    /** @deprecated */
+    experimentalIsEmpty(): boolean;
+    static fromString(s: string): Alg;
+    units(): Generator<Unit>;
+    experimentalNumUnits(): number;
+    /** @deprecated */
+    get type(): string;
+    /**
+     * Converts the Alg to a string:
+     *
+     *     const alg = new Alg([new Move("R"), new Move("U2"), new Move("L")])
+     *     // R U2 L
+     *     console.log(alg.toString())
+     */
+    toString(): string;
+    simplify(options?: SimplifyOptions): Alg;
+}
+
+export { Alg as A, Commutator as C, Grouping as G, IterationDirection as I, LineComment as L, Move as M, Newline as N, Pause as P, QuantumMove as Q, TraversalDownUp as T, Unit as U, Conjugate as a, TraversalUp as b, MoveModifications as c, directedGenerator as d, direct as e };

package/dist/types/KPuzzleDefinition-8531b592.d.ts

@@ -0,0 +1,349 @@
+import { M as Move } from './Alg-6f3dc52c';
+
+interface NotationMapper {
+    notationToInternal(move: Move): Move | null;
+    notationToExternal(move: Move): Move | null;
+}
+
+declare function parseOptions(argv: string[]): {
+    puzzleDescription: PuzzleDescription | null;
+    options: PuzzleGeometryOptions;
+};
+declare type FaceName = string;
+declare type OrientationDirection = [number, number, number];
+declare type FaceBasedOrientationDescription = [
+    [
+        FaceName,
+        OrientationDirection
+    ],
+    [
+        FaceName,
+        OrientationDirection
+    ]
+];
+declare type BaseFaceCount = 4 | 6 | 8 | 12 | 20;
+declare type FaceBasedOrientationDescriptionLookup = Record<BaseFaceCount, FaceBasedOrientationDescription>;
+declare class PuzzleGeometryFullOptions {
+    verbosity: number;
+    allMoves: boolean;
+    outerBlockMoves: boolean;
+    vertexMoves: boolean;
+    addRotations: boolean;
+    moveList: string[] | null;
+    fixedOrientation: boolean;
+    fixedPieceType: null | "e" | "v" | "f";
+    orientCenters: boolean;
+    includeCornerOrbits: boolean;
+    includeCenterOrbits: boolean;
+    includeEdgeOrbits: boolean;
+    excludeOrbits: string[];
+    optimizeOrbits: boolean;
+    grayCorners: boolean;
+    grayCenters: boolean;
+    grayEdges: boolean;
+    puzzleOrientation: FaceBasedOrientationDescription | null;
+    puzzleOrientations: FaceBasedOrientationDescriptionLookup | null;
+    scrambleAmount: number;
+    constructor(options?: PuzzleGeometryOptions);
+}
+declare type PuzzleGeometryOptions = Partial<PuzzleGeometryFullOptions>;
+
+declare class Perm {
+    n: number;
+    p: number[];
+    constructor(a: number[]);
+    toString(): string;
+    mul(p2: Perm): Perm;
+    rmul(p2: Perm): Perm;
+    inv(): Perm;
+    compareTo(p2: Perm): number;
+    toGap(): string;
+    order(): number;
+}
+
+declare class PGOrbitDef {
+    size: number;
+    mod: number;
+    constructor(size: number, mod: number);
+    reassemblySize(): number;
+}
+declare class PGOrbitsDef {
+    orbitnames: string[];
+    private orbitdefs;
+    solved: VisibleState;
+    movenames: string[];
+    moveops: PGTransform[];
+    constructor(orbitnames: string[], orbitdefs: PGOrbitDef[], solved: VisibleState, movenames: string[], moveops: PGTransform[]);
+    transformToKTransformationData(t: PGTransform): KTransformationData;
+    static transformToKTransformationData(orbitnames: string[], t: PGTransform): KTransformationData;
+    toKsolve(name: string, mapper?: NotationMapper): string[];
+    toKPuzzleDefinition(includemoves: boolean): KPuzzleDefinition;
+    optimize(): PGOrbitsDef;
+    scramble(n: number): void;
+    getScrambleTransformation(n: number): PGTransform;
+    reassemblySize(): number;
+}
+declare class PGOrbit {
+    perm: number[];
+    ori: number[];
+    orimod: number;
+    private static kcache;
+    static e(n: number, mod: number): PGOrbit;
+    constructor(perm: number[], ori: number[], orimod: number);
+    mul(b: PGOrbit): PGOrbit;
+    inv(): PGOrbit;
+    equal(b: PGOrbit): boolean;
+    killOri(): this;
+    toPerm(): Perm;
+    identicalPieces(): number[][];
+    order(): number;
+    isIdentity(): boolean;
+    private zeroOris;
+    remap(no: number[], on: number[], nv: number): PGOrbit;
+    remapVS(no: number[], nv: number): PGOrbit;
+    appendDefinition(result: string[], name: string, useVS: boolean, concise?: boolean): void;
+    toKPuzzle(): Record<string, number[]>;
+}
+declare class PGTransformBase {
+    orbits: PGOrbit[];
+    constructor(orbits: PGOrbit[]);
+    internalMul(b: PGTransformBase): PGOrbit[];
+    protected internalInv(): PGOrbit[];
+    equal(b: PGTransformBase): boolean;
+    protected killOri(): this;
+    toPerm(): Perm;
+    identicalPieces(): number[][];
+    order(): number;
+}
+declare class PGTransform extends PGTransformBase {
+    constructor(orbits: PGOrbit[]);
+    mul(b: PGTransform): PGTransform;
+    mulScalar(n: number): PGTransform;
+    inv(): PGTransform;
+    e(): PGTransform;
+}
+declare class VisibleState extends PGTransformBase {
+    constructor(orbits: PGOrbit[]);
+    mul(b: PGTransform): VisibleState;
+}
+
+declare type PuzzleDescriptionString = string;
+declare const PGPuzzles: {
+    [name: string]: PuzzleDescriptionString;
+};
+declare type PuzzleName = keyof typeof PGPuzzles;
+
+declare class Quat {
+    a: number;
+    b: number;
+    c: number;
+    d: number;
+    constructor(a: number, b: number, c: number, d: number);
+    mul(q: Quat): Quat;
+    toString(): string;
+    dist(q: Quat): number;
+    len(): number;
+    cross(q: Quat): Quat;
+    dot(q: Quat): number;
+    normalize(): Quat;
+    makenormal(): Quat;
+    normalizeplane(): Quat;
+    smul(m: number): Quat;
+    sum(q: Quat): Quat;
+    sub(q: Quat): Quat;
+    angle(): number;
+    invrot(): Quat;
+    det3x3(a00: number, a01: number, a02: number, a10: number, a11: number, a12: number, a20: number, a21: number, a22: number): number;
+    rotateplane(q: Quat): Quat;
+    orthogonal(): Quat;
+    pointrotation(b: Quat): Quat;
+    unproject(b: Quat): Quat;
+    rotatepoint(q: Quat): Quat;
+    rotateface(face: Quat[]): Quat[];
+    intersect3(p2: Quat, p3: Quat): Quat | false;
+    side(x: number): number;
+    /**
+     * Cuts a face by this plane, or returns null if there
+     * is no intersection.
+     * @param face The face to cut.
+     */
+    cutface(face: Quat[]): Quat[][] | null;
+    cutfaces(faces: Quat[][]): Quat[][];
+    faceside(face: Quat[]): number;
+    sameplane(p: Quat): boolean;
+    makecut(r: number): Quat;
+}
+
+interface TextureMapper {
+    getuv(fn: number, threed: number[]): number[];
+}
+interface StickerDatSticker {
+    coords: number[];
+    color: string;
+    orbit: string;
+    ord: number;
+    ori: number;
+    face: number;
+    isDup?: boolean;
+}
+interface StickerDatFace {
+    coords: number[];
+    name: string;
+}
+declare type StickerDatAxis = {
+    coordinates: number[];
+    quantumMove: Move;
+    order: number;
+};
+interface StickerDat {
+    stickers: StickerDatSticker[];
+    faces: StickerDatFace[];
+    axis: StickerDatAxis[];
+    unswizzle(mv: Move): Move | null;
+    notationMapper: NotationMapper;
+    textureMapper: TextureMapper;
+}
+declare function getPG3DNamedPuzzles(): {
+    [s: string]: PuzzleDescriptionString;
+};
+declare function getPuzzleDescriptionString(puzzleName: PuzzleName): PuzzleDescriptionString;
+declare type CutDescription = {
+    cutType: string;
+    distance: number;
+};
+declare type PuzzleDescription = {
+    shape: string;
+    cuts: CutDescription[];
+};
+declare function parsePuzzleDescription(s: PuzzleDescriptionString): PuzzleDescription | null;
+declare function getPuzzleGeometryByDesc(desc: string, options?: PuzzleGeometryOptions): PuzzleGeometry;
+declare function getPuzzleGeometryByName(puzzleName: PuzzleName, options?: PuzzleGeometryOptions): PuzzleGeometry;
+declare class PuzzleGeometry {
+    private puzzleDescription;
+    private rotations;
+    baseplanerot: Quat[];
+    private baseplanes;
+    private facenames;
+    private faceplanes;
+    private edgenames;
+    private vertexnames;
+    private geonormals;
+    private moveplanes;
+    private moveplanes2;
+    moveplanesets: Quat[][];
+    private moveplanenormals;
+    movesetorders: number[];
+    movesetgeos: [string, string, string, string, number][];
+    private basefaces;
+    private faces;
+    private facecentermass;
+    private baseFaceCount;
+    stickersperface: number;
+    shortedge: number;
+    cubies: number[][];
+    private vertexdistance;
+    private edgedistance;
+    private facetocubie;
+    private facetoord;
+    private moverotations;
+    private facelisthash;
+    private cubiesetnames;
+    private cubieords;
+    private cubiesetnums;
+    private cubieordnums;
+    private orbitoris;
+    private cubievaluemap;
+    private cubiesetcubies;
+    cmovesbyslice: number[][][];
+    parsedmovelist: [
+        string | undefined,
+        number,
+        number,
+        number,
+        boolean,
+        number
+    ][];
+    private duplicatedFaces;
+    private duplicatedCubies;
+    private fixedCubie;
+    private net;
+    private colors;
+    private faceorder;
+    private faceprecedence;
+    private swizzler;
+    notationMapper: NotationMapper;
+    private addNotationMapper;
+    private setReidOrder;
+    private options;
+    constructor(puzzleDescription: PuzzleDescription, options: PuzzleGeometryOptions);
+    create(puzzleDescription: PuzzleDescription): void;
+    private keyface;
+    private keyface2;
+    private keyface3;
+    private findface;
+    private project2d;
+    allstickers(): void;
+    unswizzle(mv: Move): Move | null;
+    private stringToBlockMove;
+    parseMove(move: Move): [string | undefined, number, number, number, boolean, number];
+    private parsemove;
+    genperms(): void;
+    private getboundarygeometry;
+    private getmovesets;
+    private graybyori;
+    private skipbyori;
+    private skipcubie;
+    private header;
+    writegap(): string;
+    writeksolve(name?: string): string;
+    getKPuzzleDefinition(fortwisty?: boolean, includemoves?: boolean): KPuzzleDefinition;
+    getMoveFromBits(moverange: number[], amount: number, inverted: boolean, axiscmoves: number[][], setmoves: number[] | undefined, movesetorder: number): PGTransform;
+    private omitSet;
+    private diffmvsets;
+    getOrbitsDef(fortwisty: boolean, includemoves?: boolean): PGOrbitsDef;
+    getScramble(n?: number): KTransformationData;
+    getMovesAsPerms(): Perm[];
+    showcanon(disp: (s: string) => void): void;
+    getsolved(): Perm;
+    private getOrientationRotation;
+    private getInitial3DRotation;
+    private generate2dmapping;
+    generatesvg(w?: number, h?: number, trim?: number, threed?: boolean): string;
+    get3d(options?: {
+        stickerColors?: string[];
+    }): StickerDat;
+    getGeoNormal(geoname: string): number[] | undefined;
+    private getfaceindex;
+    textForTwizzleExplorer(): string;
+    writeSchreierSims(tw: (s: string) => void): void;
+}
+declare class PGNotation {
+    private pg;
+    private orbitNames;
+    constructor(pg: PuzzleGeometry, od: PGOrbitsDef);
+    lookupMove(move: Move): KTransformationData | null;
+}
+
+declare type KTransformationData = Record<string, KTransformationOrbitData>;
+interface KTransformationOrbitData {
+    permutation: number[];
+    orientation: number[];
+}
+declare type KStateData = Record<string, KStateOrbitData>;
+interface KStateOrbitData {
+    pieces: number[];
+    orientation: number[];
+}
+interface KOrbitDefinition {
+    numPieces: number;
+    numOrientations: number;
+}
+interface KPuzzleDefinition {
+    name: string;
+    orbits: Record<string, KOrbitDefinition>;
+    startStateData: KStateData;
+    moves: Record<string, KTransformationData>;
+    experimentalDerivedMoves?: Record<string, string>;
+}
+
+export { KTransformationData as K, PGNotation as P, Quat as Q, StickerDat as S, KPuzzleDefinition as a, KStateData as b, Perm as c, getPuzzleGeometryByDesc as d, getPuzzleGeometryByName as e, getPG3DNamedPuzzles as f, getPuzzleDescriptionString as g, PuzzleGeometry as h, StickerDatAxis as i, StickerDatFace as j, StickerDatSticker as k, parseOptions as l, PuzzleDescriptionString as m, parsePuzzleDescription as p };

package/dist/types/KState-ba36d9a3.d.ts

@@ -0,0 +1,70 @@
+import { M as Move, A as Alg } from './Alg-6f3dc52c';
+import { K as KTransformationData, a as KPuzzleDefinition, P as PGNotation, b as KStateData } from './KPuzzleDefinition-8531b592';
+
+declare class KTransformation {
+    #private;
+    readonly kpuzzle: KPuzzle;
+    readonly transformationData: KTransformationData;
+    constructor(kpuzzle: KPuzzle, transformationData: KTransformationData);
+    toJSON(): any;
+    invert(): KTransformation;
+    isIdentityTransformation(): boolean;
+    /** @deprecated */
+    static experimentalConstructIdentity(kpuzzle: KPuzzle): KTransformation;
+    isIdentical(t2: KTransformation): boolean;
+    /** @deprecated */
+    apply(source: KTransformationSource): KTransformation;
+    applyTransformation(t2: KTransformation): KTransformation;
+    applyMove(move: Move | string): KTransformation;
+    applyAlg(alg: Alg | string): KTransformation;
+    toKState(): KState;
+    repetitionOrder(): number;
+    selfMultiply(amount: number): KTransformation;
+}
+
+declare type KTransformationSource = Alg | Move | string | KTransformation;
+declare class KPuzzle {
+    #private;
+    readonly definition: KPuzzleDefinition;
+    private experimentalPGNotation;
+    constructor(definition: KPuzzleDefinition, options?: {
+        experimentalPGNotation?: PGNotation;
+    });
+    name(): string;
+    identityTransformation(): KTransformation;
+    moveToTransformation(move: Move | string): KTransformation;
+    algToTransformation(alg: Alg | string): KTransformation;
+    /** @deprecated */
+    toTransformation(source: KTransformationSource): KTransformation;
+    startState(): KState;
+    canConvertStateToUniqueTransformation(): boolean;
+    /** @deprecated */
+    get state(): never;
+    /** @deprecated */
+    reset(): never;
+    /** @deprecated */
+    applyMove(_move: Move): never;
+    /** @deprecated */
+    applyAlg(_alg: Alg): never;
+}
+
+declare class KState {
+    readonly kpuzzle: KPuzzle;
+    readonly stateData: KStateData;
+    constructor(kpuzzle: KPuzzle, stateData: KStateData);
+    toJSON(): any;
+    static fromTransformation(transformation: KTransformation): KState;
+    /** @deprecated */
+    apply(source: KTransformationSource): KState;
+    applyTransformation(transformation: KTransformation): KState;
+    applyMove(move: Move | string): KState;
+    applyAlg(alg: Alg | string): KState;
+    /** @deprecated */
+    experimentalToTransformation(): KTransformation | null;
+    experimentalIs3x3x3Solved(options: {
+        ignorePuzzleOrientation: boolean;
+        ignoreCenterOrientation: boolean;
+    }): boolean;
+}
+
+export { KState as K, KPuzzle as a, KTransformation as b };