declare const alphabetSymbols: readonly ["F", "G", "H", "L", "M", "D", "U", "+", "-", "[", "]"];
type AlphabetSymbol = typeof alphabetSymbols[number];

declare class Rule {
    private _base;
    private _next;
    constructor(rule: string);
    get base(): AlphabetSymbol;
    get next(): AlphabetSymbol[];
    get nextString(): string;
    toString(): string;
}

declare class LSystem {
    private _axiom;
    private _rules;
    private _sentence;
    private _generation;
    constructor(axiom: string, rules: (string | Rule)[]);
    private init;
    /**
     *
     * @param { number } n
     */
    generate(n?: number): void;
    get sentence(): string;
    get generation(): number;
    get rules(): Rule[];
    set axiom(val: string);
    get axiom(): string;
}

interface ScaleConfig {
    ratio: number;
    scaleStrokeSize?: boolean;
    scaleStrokeWeight?: boolean;
    scaleAngle?: boolean;
}
interface TurtleConfig {
    context: CanvasRenderingContext2D;
    strokeSize: number;
    strokeWeight: number;
    angle: number;
    scale: ScaleConfig;
}
declare class Turtle {
    config: TurtleConfig;
    /**
     * @type { number }
     */
    private currentScale;
    private readonly alphabetMap;
    constructor(config: TurtleConfig);
    /**
     *
     * @param { string } sentence
     */
    render(sentence: string): void;
    /**
     *
     * @param { number } x
     * @param { number } y
     * @param { number } angle
     */
    init(x: number, y: number, angle: number): void;
}

export { type AlphabetSymbol, LSystem, Rule, Turtle };