export declare enum NodeTypes {
    Turn = "turn",
    Sequence = "sequence",
    Conjugate = "conjugate",
    Commutator = "commutator",
    Repeating = "repeating group",
    Algorithm = "algorithm"
}
export declare type FaceMove = 'U' | 'F' | 'R' | 'D' | 'B' | 'L';
export declare type WideMove = 'u' | 'f' | 'r' | 'd' | 'b' | 'l';
export declare type SliceMove = 'M' | 'E' | 'S';
export declare type RotationMove = 'x' | 'y' | 'z';
export declare type Move = FaceMove | WideMove | SliceMove | RotationMove;
export declare enum Direction {
    CW = 1,
    Double = 2,
    CCW = 3
}
declare type BaseTurnNode<M extends Move> = {
    type: NodeTypes.Turn;
    move: M;
    direction: Direction;
};
export declare type FaceTurnNode = BaseTurnNode<FaceMove>;
export declare type WideTurnNode = BaseTurnNode<WideMove>;
export declare type SliceTurnNode = BaseTurnNode<SliceMove>;
export declare type RotationTurnNode = BaseTurnNode<RotationMove>;
export declare type TurnNode = FaceTurnNode | WideTurnNode | SliceTurnNode | RotationTurnNode;
export declare type SequenceNode = {
    type: NodeTypes.Sequence;
    turns: Array<TurnNode>;
};
export declare type ConjugateNode = {
    type: NodeTypes.Conjugate;
    A: Array<Node>;
    B: Array<Node>;
};
export declare type CommutatorNode = {
    type: NodeTypes.Commutator;
    A: Array<Node>;
    B: Array<Node>;
};
export declare type RepeatingNode = {
    type: NodeTypes.Repeating;
    multiplicand: Array<Node>;
    multiplier: number;
};
export declare type AlgorithmNode = {
    type: NodeTypes.Algorithm;
    body: Array<Node>;
};
export declare type Node = TurnNode | SequenceNode | ConjugateNode | CommutatorNode | RepeatingNode | AlgorithmNode;
export declare const createTurn: <T extends TurnNode>(move: T["move"], direction: T["direction"]) => T;
export declare const createSequence: (turns?: MaybeArray<SequenceNode['turns']>) => SequenceNode;
export declare const createConjugate: (A?: MaybeArray<ConjugateNode['A']>, B?: MaybeArray<ConjugateNode['B']>) => ConjugateNode;
export declare const createCommutator: (A?: MaybeArray<CommutatorNode['A']>, B?: MaybeArray<CommutatorNode['B']>) => CommutatorNode;
export declare const createRepeating: (multiplicand?: MaybeArray<RepeatingNode['multiplicand']>, multiplier?: RepeatingNode['multiplier']) => RepeatingNode;
export declare const createAlgorithm: (body?: MaybeArray<AlgorithmNode['body']>) => AlgorithmNode;
declare type MaybeArray<T extends unknown[]> = T | T[number];
export {};