import { Question } from '../../../../../common-ui/dist/common-ui.es.js';
import { DataShape, ViewData } from '../../../../../common/dist/index.mjs';
import { NoteEvent } from '../../utility/midi';
export declare class EchoQuestion extends Question {
    static dataShapes: DataShape[];
    static views: import('vue').DefineComponent<{
        data: ViewData[];
        modifyDifficulty: number;
    }, {
        initialized: import('vue').Ref<boolean, boolean>;
        state: import('vue').Ref<string, string>;
        recording: import('vue').Ref<boolean, boolean>;
        inputSeq: import('vue').Ref<{
            syllables: {
                notes: {
                    note: {
                        number: number;
                        name: string;
                        octave: number;
                    };
                    velocity: number;
                    timestamp: number;
                    type: "noteon" | "noteoff";
                    isCorrect: boolean;
                    isMissing: boolean;
                }[];
                isCorrect: boolean | undefined;
                readonly timestamp: number;
                grade: (answer: {
                    notes: (NoteEvent & {
                        isCorrect: boolean;
                        isMissing: boolean;
                    })[];
                    isCorrect: boolean | undefined;
                    readonly timestamp: number;
                    grade(answer: /*elided*/ any): /*elided*/ any;
                }) => {
                    notes: (NoteEvent & {
                        isCorrect: boolean;
                        isMissing: boolean;
                    })[];
                    isCorrect: boolean | undefined;
                    readonly timestamp: number;
                    grade(answer: /*elided*/ any): /*elided*/ any;
                };
            }[];
            rootNote: {
                number: number;
                name: string;
                octave: number;
            };
            append: (e: NoteEvent) => void;
            grade: (answer: import('../../..').SyllableSequence) => import('../../..').SyllableSequence;
            toString: () => string;
            isCorrect: () => boolean;
        }, import('../../..').SyllableSequence | {
            syllables: {
                notes: {
                    note: {
                        number: number;
                        name: string;
                        octave: number;
                    };
                    velocity: number;
                    timestamp: number;
                    type: "noteon" | "noteoff";
                    isCorrect: boolean;
                    isMissing: boolean;
                }[];
                isCorrect: boolean | undefined;
                readonly timestamp: number;
                grade: (answer: {
                    notes: (NoteEvent & {
                        isCorrect: boolean;
                        isMissing: boolean;
                    })[];
                    isCorrect: boolean | undefined;
                    readonly timestamp: number;
                    grade(answer: /*elided*/ any): /*elided*/ any;
                }) => {
                    notes: (NoteEvent & {
                        isCorrect: boolean;
                        isMissing: boolean;
                    })[];
                    isCorrect: boolean | undefined;
                    readonly timestamp: number;
                    grade(answer: /*elided*/ any): /*elided*/ any;
                };
            }[];
            rootNote: {
                number: number;
                name: string;
                octave: number;
            };
            append: (e: NoteEvent) => void;
            grade: (answer: import('../../..').SyllableSequence) => import('../../..').SyllableSequence;
            toString: () => string;
            isCorrect: () => boolean;
        }>;
        lastTSsuggestion: import('vue').Ref<number, number>;
        gradedSeq: import('vue').Ref<{
            syllables: {
                notes: {
                    note: {
                        number: number;
                        name: string;
                        octave: number;
                    };
                    velocity: number;
                    timestamp: number;
                    type: "noteon" | "noteoff";
                    isCorrect: boolean;
                    isMissing: boolean;
                }[];
                isCorrect: boolean | undefined;
                readonly timestamp: number;
                grade: (answer: {
                    notes: (NoteEvent & {
                        isCorrect: boolean;
                        isMissing: boolean;
                    })[];
                    isCorrect: boolean | undefined;
                    readonly timestamp: number;
                    grade(answer: /*elided*/ any): /*elided*/ any;
                }) => {
                    notes: (NoteEvent & {
                        isCorrect: boolean;
                        isMissing: boolean;
                    })[];
                    isCorrect: boolean | undefined;
                    readonly timestamp: number;
                    grade(answer: /*elided*/ any): /*elided*/ any;
                };
            }[];
            rootNote: {
                number: number;
                name: string;
                octave: number;
            };
            append: (e: NoteEvent) => void;
            grade: (answer: import('../../..').SyllableSequence) => import('../../..').SyllableSequence;
            toString: () => string;
            isCorrect: () => boolean;
        }, import('../../..').SyllableSequence | {
            syllables: {
                notes: {
                    note: {
                        number: number;
                        name: string;
                        octave: number;
                    };
                    velocity: number;
                    timestamp: number;
                    type: "noteon" | "noteoff";
                    isCorrect: boolean;
                    isMissing: boolean;
                }[];
                isCorrect: boolean | undefined;
                readonly timestamp: number;
                grade: (answer: {
                    notes: (NoteEvent & {
                        isCorrect: boolean;
                        isMissing: boolean;
                    })[];
                    isCorrect: boolean | undefined;
                    readonly timestamp: number;
                    grade(answer: /*elided*/ any): /*elided*/ any;
                }) => {
                    notes: (NoteEvent & {
                        isCorrect: boolean;
                        isMissing: boolean;
                    })[];
                    isCorrect: boolean | undefined;
                    readonly timestamp: number;
                    grade(answer: /*elided*/ any): /*elided*/ any;
                };
            }[];
            rootNote: {
                number: number;
                name: string;
                octave: number;
            };
            append: (e: NoteEvent) => void;
            grade: (answer: import('../../..').SyllableSequence) => import('../../..').SyllableSequence;
            toString: () => string;
            isCorrect: () => boolean;
        }>;
        graded: import('vue').Ref<boolean, boolean>;
        promptText: import('vue').ComputedRef<"Lowest note of first chord:" | "First note:">;
        firstNoteChroma: import('vue').ComputedRef<number>;
        progressBar: import('vue').Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
        inputVisRef: import('vue').Ref<import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
            seq: {
                type: import('vue').PropType<import('../../..').SyllableSequence>;
                required: true;
            };
            lastTSsuggestion: {
                type: NumberConstructor;
                required: false;
                default: number;
            };
        }>> & Readonly<{}>, {
            firstTS: import('vue').Ref<number, number>;
            lastTS: import('vue').Ref<number, number>;
            high: import('vue').Ref<number, number>;
            low: import('vue').Ref<number, number>;
            sayNote: (note: NoteEvent) => void;
            getLastTS: import('vue').ComputedRef<number>;
            getHeight: import('vue').ComputedRef<number>;
            updateBounds: () => void;
        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
            lastTSsuggestion: number;
        }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<import('vue').ExtractPropTypes<{
            seq: {
                type: import('vue').PropType<import('../../..').SyllableSequence>;
                required: true;
            };
            lastTSsuggestion: {
                type: NumberConstructor;
                required: false;
                default: number;
            };
        }>> & Readonly<{}>, {
            firstTS: import('vue').Ref<number, number>;
            lastTS: import('vue').Ref<number, number>;
            high: import('vue').Ref<number, number>;
            low: import('vue').Ref<number, number>;
            sayNote: (note: NoteEvent) => void;
            getLastTS: import('vue').ComputedRef<number>;
            getHeight: import('vue').ComputedRef<number>;
            updateBounds: () => void;
        }, {}, {}, {}, {
            lastTSsuggestion: number;
        }> | undefined, import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
            seq: {
                type: import('vue').PropType<import('../../..').SyllableSequence>;
                required: true;
            };
            lastTSsuggestion: {
                type: NumberConstructor;
                required: false;
                default: number;
            };
        }>> & Readonly<{}>, {
            firstTS: import('vue').Ref<number, number>;
            lastTS: import('vue').Ref<number, number>;
            high: import('vue').Ref<number, number>;
            low: import('vue').Ref<number, number>;
            sayNote: (note: NoteEvent) => void;
            getLastTS: import('vue').ComputedRef<number>;
            getHeight: import('vue').ComputedRef<number>;
            updateBounds: () => void;
        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
            lastTSsuggestion: number;
        }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<import('vue').ExtractPropTypes<{
            seq: {
                type: import('vue').PropType<import('../../..').SyllableSequence>;
                required: true;
            };
            lastTSsuggestion: {
                type: NumberConstructor;
                required: false;
                default: number;
            };
        }>> & Readonly<{}>, {
            firstTS: import('vue').Ref<number, number>;
            lastTS: import('vue').Ref<number, number>;
            high: import('vue').Ref<number, number>;
            low: import('vue').Ref<number, number>;
            sayNote: (note: NoteEvent) => void;
            getLastTS: import('vue').ComputedRef<number>;
            getHeight: import('vue').ComputedRef<number>;
            updateBounds: () => void;
        }, {}, {}, {}, {
            lastTSsuggestion: number;
        }> | undefined>;
        clearAttempt: () => void;
        notesOn: import('vue').Ref<number, number>;
        priorSessionViews: import('vue').Ref<number>;
        priorAttempts: import('vue').Ref<number>;
        priorAnswers: import('vue').Ref<[import('../../../../../common/dist/index.mjs').Answer, string][]>;
        maxAttemptsPerView: import('vue').Ref<number>;
        maxSessionViews: import('vue').Ref<number>;
        question: import('vue').Ref<EchoQuestion | undefined, EchoQuestion | undefined>;
        submitAnswer: (answer: import('../../../../../common/dist/index.mjs').Answer, submittingClass?: string) => import('packages/db/dist').QuestionRecord;
        startTime: import('vue').Ref<moment.Moment>;
        hotKeys: import('vue').Ref<import('../../../../../common-ui/dist/common-ui.es.js').HotKey[]>;
        timeSpent: import('vue').ComputedRef<number>;
        logger: import('../../../../../common-ui/dist/common-ui.es.js').ViewableLogger;
        getURL: (item: string, dataShapeIndex?: number) => string;
        emitResponse: (record: import('packages/db/dist').CardRecord) => void;
    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
        data: ViewData[];
        modifyDifficulty: number;
    }> & Readonly<{}>, {
        modifyDifficulty: number;
    }, {}, {
        SyllableSeqVis: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
            seq: {
                type: import('vue').PropType<import('../../..').SyllableSequence>;
                required: true;
            };
            lastTSsuggestion: {
                type: NumberConstructor;
                required: false;
                default: number;
            };
        }>, {
            firstTS: import('vue').Ref<number, number>;
            lastTS: import('vue').Ref<number, number>;
            high: import('vue').Ref<number, number>;
            low: import('vue').Ref<number, number>;
            sayNote: (note: NoteEvent) => void;
            getLastTS: import('vue').ComputedRef<number>;
            getHeight: import('vue').ComputedRef<number>;
            updateBounds: () => void;
        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
            seq: {
                type: import('vue').PropType<import('../../..').SyllableSequence>;
                required: true;
            };
            lastTSsuggestion: {
                type: NumberConstructor;
                required: false;
                default: number;
            };
        }>> & Readonly<{}>, {
            lastTSsuggestion: number;
        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
        NoteDisplay: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
            chroma: {
                type: NumberConstructor;
                required: true;
            };
        }>, {
            style: (n: number) => {
                fill: string;
                'fill-opacity': number;
                stroke: string;
                'stroke-width': number;
                'stroke-miterlimit': number;
                'stroke-dasharray': string;
                'stroke-opacity': number;
            };
            white: number;
            black: number;
        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
            chroma: {
                type: NumberConstructor;
                required: true;
            };
        }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>[];
    midi: NoteEvent[];
    constructor(data: ViewData[]);
    /**
     * The duration of the recording in milliseconds
     */
    get duration(): number;
    /**
     * The time (in MS) at which the last note in
     * recording is played
     */
    get lastNoteOnTimestamp(): number;
    isCorrect(answer: NoteEvent[]): boolean;
    dataShapes(): DataShape[];
    views(): import('vue').DefineComponent<{
        data: ViewData[];
        modifyDifficulty: number;
    }, {
        initialized: import('vue').Ref<boolean, boolean>;
        state: import('vue').Ref<string, string>;
        recording: import('vue').Ref<boolean, boolean>;
        inputSeq: import('vue').Ref<{
            syllables: {
                notes: {
                    note: {
                        number: number;
                        name: string;
                        octave: number;
                    };
                    velocity: number;
                    timestamp: number;
                    type: "noteon" | "noteoff";
                    isCorrect: boolean;
                    isMissing: boolean;
                }[];
                isCorrect: boolean | undefined;
                readonly timestamp: number;
                grade: (answer: {
                    notes: (NoteEvent & {
                        isCorrect: boolean;
                        isMissing: boolean;
                    })[];
                    isCorrect: boolean | undefined;
                    readonly timestamp: number;
                    grade(answer: /*elided*/ any): /*elided*/ any;
                }) => {
                    notes: (NoteEvent & {
                        isCorrect: boolean;
                        isMissing: boolean;
                    })[];
                    isCorrect: boolean | undefined;
                    readonly timestamp: number;
                    grade(answer: /*elided*/ any): /*elided*/ any;
                };
            }[];
            rootNote: {
                number: number;
                name: string;
                octave: number;
            };
            append: (e: NoteEvent) => void;
            grade: (answer: import('../../..').SyllableSequence) => import('../../..').SyllableSequence;
            toString: () => string;
            isCorrect: () => boolean;
        }, import('../../..').SyllableSequence | {
            syllables: {
                notes: {
                    note: {
                        number: number;
                        name: string;
                        octave: number;
                    };
                    velocity: number;
                    timestamp: number;
                    type: "noteon" | "noteoff";
                    isCorrect: boolean;
                    isMissing: boolean;
                }[];
                isCorrect: boolean | undefined;
                readonly timestamp: number;
                grade: (answer: {
                    notes: (NoteEvent & {
                        isCorrect: boolean;
                        isMissing: boolean;
                    })[];
                    isCorrect: boolean | undefined;
                    readonly timestamp: number;
                    grade(answer: /*elided*/ any): /*elided*/ any;
                }) => {
                    notes: (NoteEvent & {
                        isCorrect: boolean;
                        isMissing: boolean;
                    })[];
                    isCorrect: boolean | undefined;
                    readonly timestamp: number;
                    grade(answer: /*elided*/ any): /*elided*/ any;
                };
            }[];
            rootNote: {
                number: number;
                name: string;
                octave: number;
            };
            append: (e: NoteEvent) => void;
            grade: (answer: import('../../..').SyllableSequence) => import('../../..').SyllableSequence;
            toString: () => string;
            isCorrect: () => boolean;
        }>;
        lastTSsuggestion: import('vue').Ref<number, number>;
        gradedSeq: import('vue').Ref<{
            syllables: {
                notes: {
                    note: {
                        number: number;
                        name: string;
                        octave: number;
                    };
                    velocity: number;
                    timestamp: number;
                    type: "noteon" | "noteoff";
                    isCorrect: boolean;
                    isMissing: boolean;
                }[];
                isCorrect: boolean | undefined;
                readonly timestamp: number;
                grade: (answer: {
                    notes: (NoteEvent & {
                        isCorrect: boolean;
                        isMissing: boolean;
                    })[];
                    isCorrect: boolean | undefined;
                    readonly timestamp: number;
                    grade(answer: /*elided*/ any): /*elided*/ any;
                }) => {
                    notes: (NoteEvent & {
                        isCorrect: boolean;
                        isMissing: boolean;
                    })[];
                    isCorrect: boolean | undefined;
                    readonly timestamp: number;
                    grade(answer: /*elided*/ any): /*elided*/ any;
                };
            }[];
            rootNote: {
                number: number;
                name: string;
                octave: number;
            };
            append: (e: NoteEvent) => void;
            grade: (answer: import('../../..').SyllableSequence) => import('../../..').SyllableSequence;
            toString: () => string;
            isCorrect: () => boolean;
        }, import('../../..').SyllableSequence | {
            syllables: {
                notes: {
                    note: {
                        number: number;
                        name: string;
                        octave: number;
                    };
                    velocity: number;
                    timestamp: number;
                    type: "noteon" | "noteoff";
                    isCorrect: boolean;
                    isMissing: boolean;
                }[];
                isCorrect: boolean | undefined;
                readonly timestamp: number;
                grade: (answer: {
                    notes: (NoteEvent & {
                        isCorrect: boolean;
                        isMissing: boolean;
                    })[];
                    isCorrect: boolean | undefined;
                    readonly timestamp: number;
                    grade(answer: /*elided*/ any): /*elided*/ any;
                }) => {
                    notes: (NoteEvent & {
                        isCorrect: boolean;
                        isMissing: boolean;
                    })[];
                    isCorrect: boolean | undefined;
                    readonly timestamp: number;
                    grade(answer: /*elided*/ any): /*elided*/ any;
                };
            }[];
            rootNote: {
                number: number;
                name: string;
                octave: number;
            };
            append: (e: NoteEvent) => void;
            grade: (answer: import('../../..').SyllableSequence) => import('../../..').SyllableSequence;
            toString: () => string;
            isCorrect: () => boolean;
        }>;
        graded: import('vue').Ref<boolean, boolean>;
        promptText: import('vue').ComputedRef<"Lowest note of first chord:" | "First note:">;
        firstNoteChroma: import('vue').ComputedRef<number>;
        progressBar: import('vue').Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
        inputVisRef: import('vue').Ref<import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
            seq: {
                type: import('vue').PropType<import('../../..').SyllableSequence>;
                required: true;
            };
            lastTSsuggestion: {
                type: NumberConstructor;
                required: false;
                default: number;
            };
        }>> & Readonly<{}>, {
            firstTS: import('vue').Ref<number, number>;
            lastTS: import('vue').Ref<number, number>;
            high: import('vue').Ref<number, number>;
            low: import('vue').Ref<number, number>;
            sayNote: (note: NoteEvent) => void;
            getLastTS: import('vue').ComputedRef<number>;
            getHeight: import('vue').ComputedRef<number>;
            updateBounds: () => void;
        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
            lastTSsuggestion: number;
        }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<import('vue').ExtractPropTypes<{
            seq: {
                type: import('vue').PropType<import('../../..').SyllableSequence>;
                required: true;
            };
            lastTSsuggestion: {
                type: NumberConstructor;
                required: false;
                default: number;
            };
        }>> & Readonly<{}>, {
            firstTS: import('vue').Ref<number, number>;
            lastTS: import('vue').Ref<number, number>;
            high: import('vue').Ref<number, number>;
            low: import('vue').Ref<number, number>;
            sayNote: (note: NoteEvent) => void;
            getLastTS: import('vue').ComputedRef<number>;
            getHeight: import('vue').ComputedRef<number>;
            updateBounds: () => void;
        }, {}, {}, {}, {
            lastTSsuggestion: number;
        }> | undefined, import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
            seq: {
                type: import('vue').PropType<import('../../..').SyllableSequence>;
                required: true;
            };
            lastTSsuggestion: {
                type: NumberConstructor;
                required: false;
                default: number;
            };
        }>> & Readonly<{}>, {
            firstTS: import('vue').Ref<number, number>;
            lastTS: import('vue').Ref<number, number>;
            high: import('vue').Ref<number, number>;
            low: import('vue').Ref<number, number>;
            sayNote: (note: NoteEvent) => void;
            getLastTS: import('vue').ComputedRef<number>;
            getHeight: import('vue').ComputedRef<number>;
            updateBounds: () => void;
        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
            lastTSsuggestion: number;
        }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<import('vue').ExtractPropTypes<{
            seq: {
                type: import('vue').PropType<import('../../..').SyllableSequence>;
                required: true;
            };
            lastTSsuggestion: {
                type: NumberConstructor;
                required: false;
                default: number;
            };
        }>> & Readonly<{}>, {
            firstTS: import('vue').Ref<number, number>;
            lastTS: import('vue').Ref<number, number>;
            high: import('vue').Ref<number, number>;
            low: import('vue').Ref<number, number>;
            sayNote: (note: NoteEvent) => void;
            getLastTS: import('vue').ComputedRef<number>;
            getHeight: import('vue').ComputedRef<number>;
            updateBounds: () => void;
        }, {}, {}, {}, {
            lastTSsuggestion: number;
        }> | undefined>;
        clearAttempt: () => void;
        notesOn: import('vue').Ref<number, number>;
        priorSessionViews: import('vue').Ref<number>;
        priorAttempts: import('vue').Ref<number>;
        priorAnswers: import('vue').Ref<[import('../../../../../common/dist/index.mjs').Answer, string][]>;
        maxAttemptsPerView: import('vue').Ref<number>;
        maxSessionViews: import('vue').Ref<number>;
        question: import('vue').Ref<EchoQuestion | undefined, EchoQuestion | undefined>;
        submitAnswer: (answer: import('../../../../../common/dist/index.mjs').Answer, submittingClass?: string) => import('packages/db/dist').QuestionRecord;
        startTime: import('vue').Ref<moment.Moment>;
        hotKeys: import('vue').Ref<import('../../../../../common-ui/dist/common-ui.es.js').HotKey[]>;
        timeSpent: import('vue').ComputedRef<number>;
        logger: import('../../../../../common-ui/dist/common-ui.es.js').ViewableLogger;
        getURL: (item: string, dataShapeIndex?: number) => string;
        emitResponse: (record: import('packages/db/dist').CardRecord) => void;
    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
        data: ViewData[];
        modifyDifficulty: number;
    }> & Readonly<{}>, {
        modifyDifficulty: number;
    }, {}, {
        SyllableSeqVis: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
            seq: {
                type: import('vue').PropType<import('../../..').SyllableSequence>;
                required: true;
            };
            lastTSsuggestion: {
                type: NumberConstructor;
                required: false;
                default: number;
            };
        }>, {
            firstTS: import('vue').Ref<number, number>;
            lastTS: import('vue').Ref<number, number>;
            high: import('vue').Ref<number, number>;
            low: import('vue').Ref<number, number>;
            sayNote: (note: NoteEvent) => void;
            getLastTS: import('vue').ComputedRef<number>;
            getHeight: import('vue').ComputedRef<number>;
            updateBounds: () => void;
        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
            seq: {
                type: import('vue').PropType<import('../../..').SyllableSequence>;
                required: true;
            };
            lastTSsuggestion: {
                type: NumberConstructor;
                required: false;
                default: number;
            };
        }>> & Readonly<{}>, {
            lastTSsuggestion: number;
        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
        NoteDisplay: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
            chroma: {
                type: NumberConstructor;
                required: true;
            };
        }>, {
            style: (n: number) => {
                fill: string;
                'fill-opacity': number;
                stroke: string;
                'stroke-width': number;
                'stroke-miterlimit': number;
                'stroke-dasharray': string;
                'stroke-opacity': number;
            };
            white: number;
            black: number;
        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
            chroma: {
                type: NumberConstructor;
                required: true;
            };
        }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>[];
}
//# sourceMappingURL=index.d.ts.map