# DO NOT EDIT! This file is auto generated by scripts/generate_chords.py.
from typing import Union, Tuple, Optional

from melodia.core import Tone, Note, Signature


def _get_parameters(
        base: Union[int, str, Tone, Note],
        duration: Union[Tuple[int, int], Signature, None] = None,
        velocity: Optional[float] = None
) -> Tuple[Tone, Signature, float]:
    if isinstance(base, int):
        base_tone = Tone(base)
    elif isinstance(base, str):
        base_tone = Tone.from_notation(base)
    elif isinstance(base, Tone):
        base_tone = base
    elif isinstance(base, Note):
        base_tone = base.tone
    else:
        raise ValueError('base must be int, str, Tone or Note')

    if duration is None:
        if isinstance(base, Note):
            base_duration = base.duration
        else:
            base_duration = Signature(1, 4)
    else:
        base_duration = duration

    if velocity is None:
        if isinstance(base, Note):
            base_velocity = base.velocity
        else:
            base_velocity = 0.75
    else:
        base_velocity = velocity

    return base_tone, base_duration, base_velocity


def major(
        base: Union[int, str, Tone, Note],
        duration: Union[Tuple[int, int], Signature, None] = None,
        velocity: Optional[float] = None
) -> Tuple[Note, Note, Note]:
    """
    This function generates Major Triad chord.

    :param base: base tone (can be integer, string, ~`melodia.core.tone.Tone` or ~`melodia.core.note.Note`)
    :param duration: duration of the chord
    :param velocity: velocity of the chord
    :return: tuple of 3 notes
    """
    base_tone, base_duration, base_velocity = _get_parameters(base, duration, velocity)

    return (
        Note(base_tone, base_duration, base_velocity),
        Note(base_tone.transposed(+4), base_duration, base_velocity),
        Note(base_tone.transposed(+7), base_duration, base_velocity)
    )


def maj(
        base: Union[int, str, Tone, Note],
        duration: Union[Tuple[int, int], Signature, None] = None,
        velocity: Optional[float] = None
) -> Tuple[Note, Note, Note]:
    """
    This function generates Major Triad chord.

    :param base: base tone (can be integer, string, ~`melodia.core.tone.Tone` or ~`melodia.core.note.Note`)
    :param duration: duration of the chord
    :param velocity: velocity of the chord
    :return: tuple of 3 notes
    """
    base_tone, base_duration, base_velocity = _get_parameters(base, duration, velocity)

    return (
        Note(base_tone, base_duration, base_velocity),
        Note(base_tone.transposed(+4), base_duration, base_velocity),
        Note(base_tone.transposed(+7), base_duration, base_velocity)
    )


def minor(
        base: Union[int, str, Tone, Note],
        duration: Union[Tuple[int, int], Signature, None] = None,
        velocity: Optional[float] = None
) -> Tuple[Note, Note, Note]:
    """
    This function generates Minor Triad chord.

    :param base: base tone (can be integer, string, ~`melodia.core.tone.Tone` or ~`melodia.core.note.Note`)
    :param duration: duration of the chord
    :param velocity: velocity of the chord
    :return: tuple of 3 notes
    """
    base_tone, base_duration, base_velocity = _get_parameters(base, duration, velocity)

    return (
        Note(base_tone, base_duration, base_velocity),
        Note(base_tone.transposed(+3), base_duration, base_velocity),
        Note(base_tone.transposed(+7), base_duration, base_velocity)
    )


def min(
        base: Union[int, str, Tone, Note],
        duration: Union[Tuple[int, int], Signature, None] = None,
        velocity: Optional[float] = None
) -> Tuple[Note, Note, Note]:
    """
    This function generates Minor Triad chord.

    :param base: base tone (can be integer, string, ~`melodia.core.tone.Tone` or ~`melodia.core.note.Note`)
    :param duration: duration of the chord
    :param velocity: velocity of the chord
    :return: tuple of 3 notes
    """
    base_tone, base_duration, base_velocity = _get_parameters(base, duration, velocity)

    return (
        Note(base_tone, base_duration, base_velocity),
        Note(base_tone.transposed(+3), base_duration, base_velocity),
        Note(base_tone.transposed(+7), base_duration, base_velocity)
    )


def augmented(
        base: Union[int, str, Tone, Note],
        duration: Union[Tuple[int, int], Signature, None] = None,
        velocity: Optional[float] = None
) -> Tuple[Note, Note, Note]:
    """
    This function generates Augmented Triad chord.

    :param base: base tone (can be integer, string, ~`melodia.core.tone.Tone` or ~`melodia.core.note.Note`)
    :param duration: duration of the chord
    :param velocity: velocity of the chord
    :return: tuple of 3 notes
    """
    base_tone, base_duration, base_velocity = _get_parameters(base, duration, velocity)

    return (
        Note(base_tone, base_duration, base_velocity),
        Note(base_tone.transposed(+4), base_duration, base_velocity),
        Note(base_tone.transposed(+8), base_duration, base_velocity)
    )


def aug(
        base: Union[int, str, Tone, Note],
        duration: Union[Tuple[int, int], Signature, None] = None,
        velocity: Optional[float] = None
) -> Tuple[Note, Note, Note]:
    """
    This function generates Augmented Triad chord.

    :param base: base tone (can be integer, string, ~`melodia.core.tone.Tone` or ~`melodia.core.note.Note`)
    :param duration: duration of the chord
    :param velocity: velocity of the chord
    :return: tuple of 3 notes
    """
    base_tone, base_duration, base_velocity = _get_parameters(base, duration, velocity)

    return (
        Note(base_tone, base_duration, base_velocity),
        Note(base_tone.transposed(+4), base_duration, base_velocity),
        Note(base_tone.transposed(+8), base_duration, base_velocity)
    )


def diminished(
        base: Union[int, str, Tone, Note],
        duration: Union[Tuple[int, int], Signature, None] = None,
        velocity: Optional[float] = None
) -> Tuple[Note, Note, Note]:
    """
    This function generates Diminished Triad chord.

    :param base: base tone (can be integer, string, ~`melodia.core.tone.Tone` or ~`melodia.core.note.Note`)
    :param duration: duration of the chord
    :param velocity: velocity of the chord
    :return: tuple of 3 notes
    """
    base_tone, base_duration, base_velocity = _get_parameters(base, duration, velocity)

    return (
        Note(base_tone, base_duration, base_velocity),
        Note(base_tone.transposed(+3), base_duration, base_velocity),
        Note(base_tone.transposed(+6), base_duration, base_velocity)
    )


def dim(
        base: Union[int, str, Tone, Note],
        duration: Union[Tuple[int, int], Signature, None] = None,
        velocity: Optional[float] = None
) -> Tuple[Note, Note, Note]:
    """
    This function generates Diminished Triad chord.

    :param base: base tone (can be integer, string, ~`melodia.core.tone.Tone` or ~`melodia.core.note.Note`)
    :param duration: duration of the chord
    :param velocity: velocity of the chord
    :return: tuple of 3 notes
    """
    base_tone, base_duration, base_velocity = _get_parameters(base, duration, velocity)

    return (
        Note(base_tone, base_duration, base_velocity),
        Note(base_tone.transposed(+3), base_duration, base_velocity),
        Note(base_tone.transposed(+6), base_duration, base_velocity)
    )


def suspended4(
        base: Union[int, str, Tone, Note],
        duration: Union[Tuple[int, int], Signature, None] = None,
        velocity: Optional[float] = None
) -> Tuple[Note, Note, Note]:
    """
    This function generates Suspended Fourth chord.

    :param base: base tone (can be integer, string, ~`melodia.core.tone.Tone` or ~`melodia.core.note.Note`)
    :param duration: duration of the chord
    :param velocity: velocity of the chord
    :return: tuple of 3 notes
    """
    base_tone, base_duration, base_velocity = _get_parameters(base, duration, velocity)

    return (
        Note(base_tone, base_duration, base_velocity),
        Note(base_tone.transposed(+5), base_duration, base_velocity),
        Note(base_tone.transposed(+7), base_duration, base_velocity)
    )


def sus4(
        base: Union[int, str, Tone, Note],
        duration: Union[Tuple[int, int], Signature, None] = None,
        velocity: Optional[float] = None
) -> Tuple[Note, Note, Note]:
    """
    This function generates Suspended Fourth chord.

    :param base: base tone (can be integer, string, ~`melodia.core.tone.Tone` or ~`melodia.core.note.Note`)
    :param duration: duration of the chord
    :param velocity: velocity of the chord
    :return: tuple of 3 notes
    """
    base_tone, base_duration, base_velocity = _get_parameters(base, duration, velocity)

    return (
        Note(base_tone, base_duration, base_velocity),
        Note(base_tone.transposed(+5), base_duration, base_velocity),
        Note(base_tone.transposed(+7), base_duration, base_velocity)
    )


def suspended2(
        base: Union[int, str, Tone, Note],
        duration: Union[Tuple[int, int], Signature, None] = None,
        velocity: Optional[float] = None
) -> Tuple[Note, Note, Note]:
    """
    This function generates Suspended Second chord.

    :param base: base tone (can be integer, string, ~`melodia.core.tone.Tone` or ~`melodia.core.note.Note`)
    :param duration: duration of the chord
    :param velocity: velocity of the chord
    :return: tuple of 3 notes
    """
    base_tone, base_duration, base_velocity = _get_parameters(base, duration, velocity)

    return (
        Note(base_tone, base_duration, base_velocity),
        Note(base_tone.transposed(+2), base_duration, base_velocity),
        Note(base_tone.transposed(+7), base_duration, base_velocity)
    )


def sus2(
        base: Union[int, str, Tone, Note],
        duration: Union[Tuple[int, int], Signature, None] = None,
        velocity: Optional[float] = None
) -> Tuple[Note, Note, Note]:
    """
    This function generates Suspended Second chord.

    :param base: base tone (can be integer, string, ~`melodia.core.tone.Tone` or ~`melodia.core.note.Note`)
    :param duration: duration of the chord
    :param velocity: velocity of the chord
    :return: tuple of 3 notes
    """
    base_tone, base_duration, base_velocity = _get_parameters(base, duration, velocity)

    return (
        Note(base_tone, base_duration, base_velocity),
        Note(base_tone.transposed(+2), base_duration, base_velocity),
        Note(base_tone.transposed(+7), base_duration, base_velocity)
    )


def major7(
        base: Union[int, str, Tone, Note],
        duration: Union[Tuple[int, int], Signature, None] = None,
        velocity: Optional[float] = None
) -> Tuple[Note, Note, Note, Note]:
    """
    This function generates Major Seventh chord.

    :param base: base tone (can be integer, string, ~`melodia.core.tone.Tone` or ~`melodia.core.note.Note`)
    :param duration: duration of the chord
    :param velocity: velocity of the chord
    :return: tuple of 4 notes
    """
    base_tone, base_duration, base_velocity = _get_parameters(base, duration, velocity)

    return (
        Note(base_tone, base_duration, base_velocity),
        Note(base_tone.transposed(+4), base_duration, base_velocity),
        Note(base_tone.transposed(+7), base_duration, base_velocity),
        Note(base_tone.transposed(+11), base_duration, base_velocity)
    )


def maj7(
        base: Union[int, str, Tone, Note],
        duration: Union[Tuple[int, int], Signature, None] = None,
        velocity: Optional[float] = None
) -> Tuple[Note, Note, Note, Note]:
    """
    This function generates Major Seventh chord.

    :param base: base tone (can be integer, string, ~`melodia.core.tone.Tone` or ~`melodia.core.note.Note`)
    :param duration: duration of the chord
    :param velocity: velocity of the chord
    :return: tuple of 4 notes
    """
    base_tone, base_duration, base_velocity = _get_parameters(base, duration, velocity)

    return (
        Note(base_tone, base_duration, base_velocity),
        Note(base_tone.transposed(+4), base_duration, base_velocity),
        Note(base_tone.transposed(+7), base_duration, base_velocity),
        Note(base_tone.transposed(+11), base_duration, base_velocity)
    )


def minor7(
        base: Union[int, str, Tone, Note],
        duration: Union[Tuple[int, int], Signature, None] = None,
        velocity: Optional[float] = None
) -> Tuple[Note, Note, Note, Note]:
    """
    This function generates Minor Seventh chord.

    :param base: base tone (can be integer, string, ~`melodia.core.tone.Tone` or ~`melodia.core.note.Note`)
    :param duration: duration of the chord
    :param velocity: velocity of the chord
    :return: tuple of 4 notes
    """
    base_tone, base_duration, base_velocity = _get_parameters(base, duration, velocity)

    return (
        Note(base_tone, base_duration, base_velocity),
        Note(base_tone.transposed(+3), base_duration, base_velocity),
        Note(base_tone.transposed(+7), base_duration, base_velocity),
        Note(base_tone.transposed(+10), base_duration, base_velocity)
    )


def min7(
        base: Union[int, str, Tone, Note],
        duration: Union[Tuple[int, int], Signature, None] = None,
        velocity: Optional[float] = None
) -> Tuple[Note, Note, Note, Note]:
    """
    This function generates Minor Seventh chord.

    :param base: base tone (can be integer, string, ~`melodia.core.tone.Tone` or ~`melodia.core.note.Note`)
    :param duration: duration of the chord
    :param velocity: velocity of the chord
    :return: tuple of 4 notes
    """
    base_tone, base_duration, base_velocity = _get_parameters(base, duration, velocity)

    return (
        Note(base_tone, base_duration, base_velocity),
        Note(base_tone.transposed(+3), base_duration, base_velocity),
        Note(base_tone.transposed(+7), base_duration, base_velocity),
        Note(base_tone.transposed(+10), base_duration, base_velocity)
    )


def dominant7(
        base: Union[int, str, Tone, Note],
        duration: Union[Tuple[int, int], Signature, None] = None,
        velocity: Optional[float] = None
) -> Tuple[Note, Note, Note, Note]:
    """
    This function generates Dominant Seventh chord.

    :param base: base tone (can be integer, string, ~`melodia.core.tone.Tone` or ~`melodia.core.note.Note`)
    :param duration: duration of the chord
    :param velocity: velocity of the chord
    :return: tuple of 4 notes
    """
    base_tone, base_duration, base_velocity = _get_parameters(base, duration, velocity)

    return (
        Note(base_tone, base_duration, base_velocity),
        Note(base_tone.transposed(+4), base_duration, base_velocity),
        Note(base_tone.transposed(+7), base_duration, base_velocity),
        Note(base_tone.transposed(+10), base_duration, base_velocity)
    )


def dom7(
        base: Union[int, str, Tone, Note],
        duration: Union[Tuple[int, int], Signature, None] = None,
        velocity: Optional[float] = None
) -> Tuple[Note, Note, Note, Note]:
    """
    This function generates Dominant Seventh chord.

    :param base: base tone (can be integer, string, ~`melodia.core.tone.Tone` or ~`melodia.core.note.Note`)
    :param duration: duration of the chord
    :param velocity: velocity of the chord
    :return: tuple of 4 notes
    """
    base_tone, base_duration, base_velocity = _get_parameters(base, duration, velocity)

    return (
        Note(base_tone, base_duration, base_velocity),
        Note(base_tone.transposed(+4), base_duration, base_velocity),
        Note(base_tone.transposed(+7), base_duration, base_velocity),
        Note(base_tone.transposed(+10), base_duration, base_velocity)
    )


def dominant7b5(
        base: Union[int, str, Tone, Note],
        duration: Union[Tuple[int, int], Signature, None] = None,
        velocity: Optional[float] = None
) -> Tuple[Note, Note, Note, Note]:
    """
    This function generates Dominant Seventh Flat Five chord.

    :param base: base tone (can be integer, string, ~`melodia.core.tone.Tone` or ~`melodia.core.note.Note`)
    :param duration: duration of the chord
    :param velocity: velocity of the chord
    :return: tuple of 4 notes
    """
    base_tone, base_duration, base_velocity = _get_parameters(base, duration, velocity)

    return (
        Note(base_tone, base_duration, base_velocity),
        Note(base_tone.transposed(+4), base_duration, base_velocity),
        Note(base_tone.transposed(+6), base_duration, base_velocity),
        Note(base_tone.transposed(+10), base_duration, base_velocity)
    )


def dom7b5(
        base: Union[int, str, Tone, Note],
        duration: Union[Tuple[int, int], Signature, None] = None,
        velocity: Optional[float] = None
) -> Tuple[Note, Note, Note, Note]:
    """
    This function generates Dominant Seventh Flat Five chord.

    :param base: base tone (can be integer, string, ~`melodia.core.tone.Tone` or ~`melodia.core.note.Note`)
    :param duration: duration of the chord
    :param velocity: velocity of the chord
    :return: tuple of 4 notes
    """
    base_tone, base_duration, base_velocity = _get_parameters(base, duration, velocity)

    return (
        Note(base_tone, base_duration, base_velocity),
        Note(base_tone.transposed(+4), base_duration, base_velocity),
        Note(base_tone.transposed(+6), base_duration, base_velocity),
        Note(base_tone.transposed(+10), base_duration, base_velocity)
    )


def diminished7(
        base: Union[int, str, Tone, Note],
        duration: Union[Tuple[int, int], Signature, None] = None,
        velocity: Optional[float] = None
) -> Tuple[Note, Note, Note, Note]:
    """
    This function generates Diminished Seventh chord.

    :param base: base tone (can be integer, string, ~`melodia.core.tone.Tone` or ~`melodia.core.note.Note`)
    :param duration: duration of the chord
    :param velocity: velocity of the chord
    :return: tuple of 4 notes
    """
    base_tone, base_duration, base_velocity = _get_parameters(base, duration, velocity)

    return (
        Note(base_tone, base_duration, base_velocity),
        Note(base_tone.transposed(+3), base_duration, base_velocity),
        Note(base_tone.transposed(+6), base_duration, base_velocity),
        Note(base_tone.transposed(+9), base_duration, base_velocity)
    )


def dim7(
        base: Union[int, str, Tone, Note],
        duration: Union[Tuple[int, int], Signature, None] = None,
        velocity: Optional[float] = None
) -> Tuple[Note, Note, Note, Note]:
    """
    This function generates Diminished Seventh chord.

    :param base: base tone (can be integer, string, ~`melodia.core.tone.Tone` or ~`melodia.core.note.Note`)
    :param duration: duration of the chord
    :param velocity: velocity of the chord
    :return: tuple of 4 notes
    """
    base_tone, base_duration, base_velocity = _get_parameters(base, duration, velocity)

    return (
        Note(base_tone, base_duration, base_velocity),
        Note(base_tone.transposed(+3), base_duration, base_velocity),
        Note(base_tone.transposed(+6), base_duration, base_velocity),
        Note(base_tone.transposed(+9), base_duration, base_velocity)
    )


def minor7b5(
        base: Union[int, str, Tone, Note],
        duration: Union[Tuple[int, int], Signature, None] = None,
        velocity: Optional[float] = None
) -> Tuple[Note, Note, Note, Note]:
    """
    This function generates Half Diminished Seventh chord.

    :param base: base tone (can be integer, string, ~`melodia.core.tone.Tone` or ~`melodia.core.note.Note`)
    :param duration: duration of the chord
    :param velocity: velocity of the chord
    :return: tuple of 4 notes
    """
    base_tone, base_duration, base_velocity = _get_parameters(base, duration, velocity)

    return (
        Note(base_tone, base_duration, base_velocity),
        Note(base_tone.transposed(+3), base_duration, base_velocity),
        Note(base_tone.transposed(+6), base_duration, base_velocity),
        Note(base_tone.transposed(+10), base_duration, base_velocity)
    )


def min7b5(
        base: Union[int, str, Tone, Note],
        duration: Union[Tuple[int, int], Signature, None] = None,
        velocity: Optional[float] = None
) -> Tuple[Note, Note, Note, Note]:
    """
    This function generates Half Diminished Seventh chord.

    :param base: base tone (can be integer, string, ~`melodia.core.tone.Tone` or ~`melodia.core.note.Note`)
    :param duration: duration of the chord
    :param velocity: velocity of the chord
    :return: tuple of 4 notes
    """
    base_tone, base_duration, base_velocity = _get_parameters(base, duration, velocity)

    return (
        Note(base_tone, base_duration, base_velocity),
        Note(base_tone.transposed(+3), base_duration, base_velocity),
        Note(base_tone.transposed(+6), base_duration, base_velocity),
        Note(base_tone.transposed(+10), base_duration, base_velocity)
    )


def diminished_major7(
        base: Union[int, str, Tone, Note],
        duration: Union[Tuple[int, int], Signature, None] = None,
        velocity: Optional[float] = None
) -> Tuple[Note, Note, Note, Note]:
    """
    This function generates Diminished Major Seventh chord.

    :param base: base tone (can be integer, string, ~`melodia.core.tone.Tone` or ~`melodia.core.note.Note`)
    :param duration: duration of the chord
    :param velocity: velocity of the chord
    :return: tuple of 4 notes
    """
    base_tone, base_duration, base_velocity = _get_parameters(base, duration, velocity)

    return (
        Note(base_tone, base_duration, base_velocity),
        Note(base_tone.transposed(+3), base_duration, base_velocity),
        Note(base_tone.transposed(+6), base_duration, base_velocity),
        Note(base_tone.transposed(+11), base_duration, base_velocity)
    )


def minor_major7(
        base: Union[int, str, Tone, Note],
        duration: Union[Tuple[int, int], Signature, None] = None,
        velocity: Optional[float] = None
) -> Tuple[Note, Note, Note, Note]:
    """
    This function generates Minor Major Seventh chord.

    :param base: base tone (can be integer, string, ~`melodia.core.tone.Tone` or ~`melodia.core.note.Note`)
    :param duration: duration of the chord
    :param velocity: velocity of the chord
    :return: tuple of 4 notes
    """
    base_tone, base_duration, base_velocity = _get_parameters(base, duration, velocity)

    return (
        Note(base_tone, base_duration, base_velocity),
        Note(base_tone.transposed(+3), base_duration, base_velocity),
        Note(base_tone.transposed(+7), base_duration, base_velocity),
        Note(base_tone.transposed(+11), base_duration, base_velocity)
    )


def augmented_major7(
        base: Union[int, str, Tone, Note],
        duration: Union[Tuple[int, int], Signature, None] = None,
        velocity: Optional[float] = None
) -> Tuple[Note, Note, Note, Note]:
    """
    This function generates Augmented Major Seventh chord.

    :param base: base tone (can be integer, string, ~`melodia.core.tone.Tone` or ~`melodia.core.note.Note`)
    :param duration: duration of the chord
    :param velocity: velocity of the chord
    :return: tuple of 4 notes
    """
    base_tone, base_duration, base_velocity = _get_parameters(base, duration, velocity)

    return (
        Note(base_tone, base_duration, base_velocity),
        Note(base_tone.transposed(+4), base_duration, base_velocity),
        Note(base_tone.transposed(+8), base_duration, base_velocity),
        Note(base_tone.transposed(+11), base_duration, base_velocity)
    )


def major7s5(
        base: Union[int, str, Tone, Note],
        duration: Union[Tuple[int, int], Signature, None] = None,
        velocity: Optional[float] = None
) -> Tuple[Note, Note, Note, Note]:
    """
    This function generates Augmented Major Seventh chord.

    :param base: base tone (can be integer, string, ~`melodia.core.tone.Tone` or ~`melodia.core.note.Note`)
    :param duration: duration of the chord
    :param velocity: velocity of the chord
    :return: tuple of 4 notes
    """
    base_tone, base_duration, base_velocity = _get_parameters(base, duration, velocity)

    return (
        Note(base_tone, base_duration, base_velocity),
        Note(base_tone.transposed(+4), base_duration, base_velocity),
        Note(base_tone.transposed(+8), base_duration, base_velocity),
        Note(base_tone.transposed(+11), base_duration, base_velocity)
    )


def maj7s5(
        base: Union[int, str, Tone, Note],
        duration: Union[Tuple[int, int], Signature, None] = None,
        velocity: Optional[float] = None
) -> Tuple[Note, Note, Note, Note]:
    """
    This function generates Augmented Major Seventh chord.

    :param base: base tone (can be integer, string, ~`melodia.core.tone.Tone` or ~`melodia.core.note.Note`)
    :param duration: duration of the chord
    :param velocity: velocity of the chord
    :return: tuple of 4 notes
    """
    base_tone, base_duration, base_velocity = _get_parameters(base, duration, velocity)

    return (
        Note(base_tone, base_duration, base_velocity),
        Note(base_tone.transposed(+4), base_duration, base_velocity),
        Note(base_tone.transposed(+8), base_duration, base_velocity),
        Note(base_tone.transposed(+11), base_duration, base_velocity)
    )


def augmented_minor7(
        base: Union[int, str, Tone, Note],
        duration: Union[Tuple[int, int], Signature, None] = None,
        velocity: Optional[float] = None
) -> Tuple[Note, Note, Note, Note]:
    """
    This function generates Augmented Minor Seventh chord.

    :param base: base tone (can be integer, string, ~`melodia.core.tone.Tone` or ~`melodia.core.note.Note`)
    :param duration: duration of the chord
    :param velocity: velocity of the chord
    :return: tuple of 4 notes
    """
    base_tone, base_duration, base_velocity = _get_parameters(base, duration, velocity)

    return (
        Note(base_tone, base_duration, base_velocity),
        Note(base_tone.transposed(+4), base_duration, base_velocity),
        Note(base_tone.transposed(+8), base_duration, base_velocity),
        Note(base_tone.transposed(+10), base_duration, base_velocity)
    )


def augmented7(
        base: Union[int, str, Tone, Note],
        duration: Union[Tuple[int, int], Signature, None] = None,
        velocity: Optional[float] = None
) -> Tuple[Note, Note, Note, Note]:
    """
    This function generates Augmented Minor Seventh chord.

    :param base: base tone (can be integer, string, ~`melodia.core.tone.Tone` or ~`melodia.core.note.Note`)
    :param duration: duration of the chord
    :param velocity: velocity of the chord
    :return: tuple of 4 notes
    """
    base_tone, base_duration, base_velocity = _get_parameters(base, duration, velocity)

    return (
        Note(base_tone, base_duration, base_velocity),
        Note(base_tone.transposed(+4), base_duration, base_velocity),
        Note(base_tone.transposed(+8), base_duration, base_velocity),
        Note(base_tone.transposed(+10), base_duration, base_velocity)
    )


def aug7(
        base: Union[int, str, Tone, Note],
        duration: Union[Tuple[int, int], Signature, None] = None,
        velocity: Optional[float] = None
) -> Tuple[Note, Note, Note, Note]:
    """
    This function generates Augmented Minor Seventh chord.

    :param base: base tone (can be integer, string, ~`melodia.core.tone.Tone` or ~`melodia.core.note.Note`)
    :param duration: duration of the chord
    :param velocity: velocity of the chord
    :return: tuple of 4 notes
    """
    base_tone, base_duration, base_velocity = _get_parameters(base, duration, velocity)

    return (
        Note(base_tone, base_duration, base_velocity),
        Note(base_tone.transposed(+4), base_duration, base_velocity),
        Note(base_tone.transposed(+8), base_duration, base_velocity),
        Note(base_tone.transposed(+10), base_duration, base_velocity)
    )


def major9(
        base: Union[int, str, Tone, Note],
        duration: Union[Tuple[int, int], Signature, None] = None,
        velocity: Optional[float] = None
) -> Tuple[Note, Note, Note, Note, Note]:
    """
    This function generates Major Ninth chord.

    :param base: base tone (can be integer, string, ~`melodia.core.tone.Tone` or ~`melodia.core.note.Note`)
    :param duration: duration of the chord
    :param velocity: velocity of the chord
    :return: tuple of 5 notes
    """
    base_tone, base_duration, base_velocity = _get_parameters(base, duration, velocity)

    return (
        Note(base_tone, base_duration, base_velocity),
        Note(base_tone.transposed(+4), base_duration, base_velocity),
        Note(base_tone.transposed(+7), base_duration, base_velocity),
        Note(base_tone.transposed(+11), base_duration, base_velocity),
        Note(base_tone.transposed(+14), base_duration, base_velocity)
    )


def maj9(
        base: Union[int, str, Tone, Note],
        duration: Union[Tuple[int, int], Signature, None] = None,
        velocity: Optional[float] = None
) -> Tuple[Note, Note, Note, Note, Note]:
    """
    This function generates Major Ninth chord.

    :param base: base tone (can be integer, string, ~`melodia.core.tone.Tone` or ~`melodia.core.note.Note`)
    :param duration: duration of the chord
    :param velocity: velocity of the chord
    :return: tuple of 5 notes
    """
    base_tone, base_duration, base_velocity = _get_parameters(base, duration, velocity)

    return (
        Note(base_tone, base_duration, base_velocity),
        Note(base_tone.transposed(+4), base_duration, base_velocity),
        Note(base_tone.transposed(+7), base_duration, base_velocity),
        Note(base_tone.transposed(+11), base_duration, base_velocity),
        Note(base_tone.transposed(+14), base_duration, base_velocity)
    )


def minor9(
        base: Union[int, str, Tone, Note],
        duration: Union[Tuple[int, int], Signature, None] = None,
        velocity: Optional[float] = None
) -> Tuple[Note, Note, Note, Note, Note]:
    """
    This function generates Minor Ninth chord.

    :param base: base tone (can be integer, string, ~`melodia.core.tone.Tone` or ~`melodia.core.note.Note`)
    :param duration: duration of the chord
    :param velocity: velocity of the chord
    :return: tuple of 5 notes
    """
    base_tone, base_duration, base_velocity = _get_parameters(base, duration, velocity)

    return (
        Note(base_tone, base_duration, base_velocity),
        Note(base_tone.transposed(+3), base_duration, base_velocity),
        Note(base_tone.transposed(+7), base_duration, base_velocity),
        Note(base_tone.transposed(+10), base_duration, base_velocity),
        Note(base_tone.transposed(+14), base_duration, base_velocity)
    )


def min9(
        base: Union[int, str, Tone, Note],
        duration: Union[Tuple[int, int], Signature, None] = None,
        velocity: Optional[float] = None
) -> Tuple[Note, Note, Note, Note, Note]:
    """
    This function generates Minor Ninth chord.

    :param base: base tone (can be integer, string, ~`melodia.core.tone.Tone` or ~`melodia.core.note.Note`)
    :param duration: duration of the chord
    :param velocity: velocity of the chord
    :return: tuple of 5 notes
    """
    base_tone, base_duration, base_velocity = _get_parameters(base, duration, velocity)

    return (
        Note(base_tone, base_duration, base_velocity),
        Note(base_tone.transposed(+3), base_duration, base_velocity),
        Note(base_tone.transposed(+7), base_duration, base_velocity),
        Note(base_tone.transposed(+10), base_duration, base_velocity),
        Note(base_tone.transposed(+14), base_duration, base_velocity)
    )


def dominant9(
        base: Union[int, str, Tone, Note],
        duration: Union[Tuple[int, int], Signature, None] = None,
        velocity: Optional[float] = None
) -> Tuple[Note, Note, Note, Note, Note]:
    """
    This function generates Dominant Ninth chord.

    :param base: base tone (can be integer, string, ~`melodia.core.tone.Tone` or ~`melodia.core.note.Note`)
    :param duration: duration of the chord
    :param velocity: velocity of the chord
    :return: tuple of 5 notes
    """
    base_tone, base_duration, base_velocity = _get_parameters(base, duration, velocity)

    return (
        Note(base_tone, base_duration, base_velocity),
        Note(base_tone.transposed(+4), base_duration, base_velocity),
        Note(base_tone.transposed(+7), base_duration, base_velocity),
        Note(base_tone.transposed(+10), base_duration, base_velocity),
        Note(base_tone.transposed(+14), base_duration, base_velocity)
    )


def dom9(
        base: Union[int, str, Tone, Note],
        duration: Union[Tuple[int, int], Signature, None] = None,
        velocity: Optional[float] = None
) -> Tuple[Note, Note, Note, Note, Note]:
    """
    This function generates Dominant Ninth chord.

    :param base: base tone (can be integer, string, ~`melodia.core.tone.Tone` or ~`melodia.core.note.Note`)
    :param duration: duration of the chord
    :param velocity: velocity of the chord
    :return: tuple of 5 notes
    """
    base_tone, base_duration, base_velocity = _get_parameters(base, duration, velocity)

    return (
        Note(base_tone, base_duration, base_velocity),
        Note(base_tone.transposed(+4), base_duration, base_velocity),
        Note(base_tone.transposed(+7), base_duration, base_velocity),
        Note(base_tone.transposed(+10), base_duration, base_velocity),
        Note(base_tone.transposed(+14), base_duration, base_velocity)
    )


def dominant_minor9(
        base: Union[int, str, Tone, Note],
        duration: Union[Tuple[int, int], Signature, None] = None,
        velocity: Optional[float] = None
) -> Tuple[Note, Note, Note, Note, Note]:
    """
    This function generates Dominant Minor Ninth chord.

    :param base: base tone (can be integer, string, ~`melodia.core.tone.Tone` or ~`melodia.core.note.Note`)
    :param duration: duration of the chord
    :param velocity: velocity of the chord
    :return: tuple of 5 notes
    """
    base_tone, base_duration, base_velocity = _get_parameters(base, duration, velocity)

    return (
        Note(base_tone, base_duration, base_velocity),
        Note(base_tone.transposed(+4), base_duration, base_velocity),
        Note(base_tone.transposed(+7), base_duration, base_velocity),
        Note(base_tone.transposed(+10), base_duration, base_velocity),
        Note(base_tone.transposed(+13), base_duration, base_velocity)
    )


def min7b9(
        base: Union[int, str, Tone, Note],
        duration: Union[Tuple[int, int], Signature, None] = None,
        velocity: Optional[float] = None
) -> Tuple[Note, Note, Note, Note, Note]:
    """
    This function generates Dominant Minor Ninth chord.

    :param base: base tone (can be integer, string, ~`melodia.core.tone.Tone` or ~`melodia.core.note.Note`)
    :param duration: duration of the chord
    :param velocity: velocity of the chord
    :return: tuple of 5 notes
    """
    base_tone, base_duration, base_velocity = _get_parameters(base, duration, velocity)

    return (
        Note(base_tone, base_duration, base_velocity),
        Note(base_tone.transposed(+4), base_duration, base_velocity),
        Note(base_tone.transposed(+7), base_duration, base_velocity),
        Note(base_tone.transposed(+10), base_duration, base_velocity),
        Note(base_tone.transposed(+13), base_duration, base_velocity)
    )


def minor69(
        base: Union[int, str, Tone, Note],
        duration: Union[Tuple[int, int], Signature, None] = None,
        velocity: Optional[float] = None
) -> Tuple[Note, Note, Note, Note, Note]:
    """
    This function generates 6/9 chord.

    :param base: base tone (can be integer, string, ~`melodia.core.tone.Tone` or ~`melodia.core.note.Note`)
    :param duration: duration of the chord
    :param velocity: velocity of the chord
    :return: tuple of 5 notes
    """
    base_tone, base_duration, base_velocity = _get_parameters(base, duration, velocity)

    return (
        Note(base_tone, base_duration, base_velocity),
        Note(base_tone.transposed(+4), base_duration, base_velocity),
        Note(base_tone.transposed(+7), base_duration, base_velocity),
        Note(base_tone.transposed(+9), base_duration, base_velocity),
        Note(base_tone.transposed(+14), base_duration, base_velocity)
    )


def min69(
        base: Union[int, str, Tone, Note],
        duration: Union[Tuple[int, int], Signature, None] = None,
        velocity: Optional[float] = None
) -> Tuple[Note, Note, Note, Note, Note]:
    """
    This function generates 6/9 chord.

    :param base: base tone (can be integer, string, ~`melodia.core.tone.Tone` or ~`melodia.core.note.Note`)
    :param duration: duration of the chord
    :param velocity: velocity of the chord
    :return: tuple of 5 notes
    """
    base_tone, base_duration, base_velocity = _get_parameters(base, duration, velocity)

    return (
        Note(base_tone, base_duration, base_velocity),
        Note(base_tone.transposed(+4), base_duration, base_velocity),
        Note(base_tone.transposed(+7), base_duration, base_velocity),
        Note(base_tone.transposed(+9), base_duration, base_velocity),
        Note(base_tone.transposed(+14), base_duration, base_velocity)
    )


def added9(
        base: Union[int, str, Tone, Note],
        duration: Union[Tuple[int, int], Signature, None] = None,
        velocity: Optional[float] = None
) -> Tuple[Note, Note, Note]:
    """
    This function generates Added Ninth chord.

    :param base: base tone (can be integer, string, ~`melodia.core.tone.Tone` or ~`melodia.core.note.Note`)
    :param duration: duration of the chord
    :param velocity: velocity of the chord
    :return: tuple of 3 notes
    """
    base_tone, base_duration, base_velocity = _get_parameters(base, duration, velocity)

    return (
        Note(base_tone, base_duration, base_velocity),
        Note(base_tone.transposed(+4), base_duration, base_velocity),
        Note(base_tone.transposed(+14), base_duration, base_velocity)
    )


def add9(
        base: Union[int, str, Tone, Note],
        duration: Union[Tuple[int, int], Signature, None] = None,
        velocity: Optional[float] = None
) -> Tuple[Note, Note, Note]:
    """
    This function generates Added Ninth chord.

    :param base: base tone (can be integer, string, ~`melodia.core.tone.Tone` or ~`melodia.core.note.Note`)
    :param duration: duration of the chord
    :param velocity: velocity of the chord
    :return: tuple of 3 notes
    """
    base_tone, base_duration, base_velocity = _get_parameters(base, duration, velocity)

    return (
        Note(base_tone, base_duration, base_velocity),
        Note(base_tone.transposed(+4), base_duration, base_velocity),
        Note(base_tone.transposed(+14), base_duration, base_velocity)
    )


def major11(
        base: Union[int, str, Tone, Note],
        duration: Union[Tuple[int, int], Signature, None] = None,
        velocity: Optional[float] = None
) -> Tuple[Note, Note, Note, Note, Note, Note]:
    """
    This function generates Major Eleventh chord.

    :param base: base tone (can be integer, string, ~`melodia.core.tone.Tone` or ~`melodia.core.note.Note`)
    :param duration: duration of the chord
    :param velocity: velocity of the chord
    :return: tuple of 6 notes
    """
    base_tone, base_duration, base_velocity = _get_parameters(base, duration, velocity)

    return (
        Note(base_tone, base_duration, base_velocity),
        Note(base_tone.transposed(+4), base_duration, base_velocity),
        Note(base_tone.transposed(+7), base_duration, base_velocity),
        Note(base_tone.transposed(+11), base_duration, base_velocity),
        Note(base_tone.transposed(+14), base_duration, base_velocity),
        Note(base_tone.transposed(+17), base_duration, base_velocity)
    )


def maj11(
        base: Union[int, str, Tone, Note],
        duration: Union[Tuple[int, int], Signature, None] = None,
        velocity: Optional[float] = None
) -> Tuple[Note, Note, Note, Note, Note, Note]:
    """
    This function generates Major Eleventh chord.

    :param base: base tone (can be integer, string, ~`melodia.core.tone.Tone` or ~`melodia.core.note.Note`)
    :param duration: duration of the chord
    :param velocity: velocity of the chord
    :return: tuple of 6 notes
    """
    base_tone, base_duration, base_velocity = _get_parameters(base, duration, velocity)

    return (
        Note(base_tone, base_duration, base_velocity),
        Note(base_tone.transposed(+4), base_duration, base_velocity),
        Note(base_tone.transposed(+7), base_duration, base_velocity),
        Note(base_tone.transposed(+11), base_duration, base_velocity),
        Note(base_tone.transposed(+14), base_duration, base_velocity),
        Note(base_tone.transposed(+17), base_duration, base_velocity)
    )


def minor11(
        base: Union[int, str, Tone, Note],
        duration: Union[Tuple[int, int], Signature, None] = None,
        velocity: Optional[float] = None
) -> Tuple[Note, Note, Note, Note, Note, Note]:
    """
    This function generates Minor Eleventh chord.

    :param base: base tone (can be integer, string, ~`melodia.core.tone.Tone` or ~`melodia.core.note.Note`)
    :param duration: duration of the chord
    :param velocity: velocity of the chord
    :return: tuple of 6 notes
    """
    base_tone, base_duration, base_velocity = _get_parameters(base, duration, velocity)

    return (
        Note(base_tone, base_duration, base_velocity),
        Note(base_tone.transposed(+3), base_duration, base_velocity),
        Note(base_tone.transposed(+7), base_duration, base_velocity),
        Note(base_tone.transposed(+10), base_duration, base_velocity),
        Note(base_tone.transposed(+14), base_duration, base_velocity),
        Note(base_tone.transposed(+17), base_duration, base_velocity)
    )


def min11(
        base: Union[int, str, Tone, Note],
        duration: Union[Tuple[int, int], Signature, None] = None,
        velocity: Optional[float] = None
) -> Tuple[Note, Note, Note, Note, Note, Note]:
    """
    This function generates Minor Eleventh chord.

    :param base: base tone (can be integer, string, ~`melodia.core.tone.Tone` or ~`melodia.core.note.Note`)
    :param duration: duration of the chord
    :param velocity: velocity of the chord
    :return: tuple of 6 notes
    """
    base_tone, base_duration, base_velocity = _get_parameters(base, duration, velocity)

    return (
        Note(base_tone, base_duration, base_velocity),
        Note(base_tone.transposed(+3), base_duration, base_velocity),
        Note(base_tone.transposed(+7), base_duration, base_velocity),
        Note(base_tone.transposed(+10), base_duration, base_velocity),
        Note(base_tone.transposed(+14), base_duration, base_velocity),
        Note(base_tone.transposed(+17), base_duration, base_velocity)
    )


def dominant11(
        base: Union[int, str, Tone, Note],
        duration: Union[Tuple[int, int], Signature, None] = None,
        velocity: Optional[float] = None
) -> Tuple[Note, Note, Note, Note, Note, Note]:
    """
    This function generates Dominant Eleventh chord.

    :param base: base tone (can be integer, string, ~`melodia.core.tone.Tone` or ~`melodia.core.note.Note`)
    :param duration: duration of the chord
    :param velocity: velocity of the chord
    :return: tuple of 6 notes
    """
    base_tone, base_duration, base_velocity = _get_parameters(base, duration, velocity)

    return (
        Note(base_tone, base_duration, base_velocity),
        Note(base_tone.transposed(+4), base_duration, base_velocity),
        Note(base_tone.transposed(+7), base_duration, base_velocity),
        Note(base_tone.transposed(+10), base_duration, base_velocity),
        Note(base_tone.transposed(+14), base_duration, base_velocity),
        Note(base_tone.transposed(+17), base_duration, base_velocity)
    )


def dom11(
        base: Union[int, str, Tone, Note],
        duration: Union[Tuple[int, int], Signature, None] = None,
        velocity: Optional[float] = None
) -> Tuple[Note, Note, Note, Note, Note, Note]:
    """
    This function generates Dominant Eleventh chord.

    :param base: base tone (can be integer, string, ~`melodia.core.tone.Tone` or ~`melodia.core.note.Note`)
    :param duration: duration of the chord
    :param velocity: velocity of the chord
    :return: tuple of 6 notes
    """
    base_tone, base_duration, base_velocity = _get_parameters(base, duration, velocity)

    return (
        Note(base_tone, base_duration, base_velocity),
        Note(base_tone.transposed(+4), base_duration, base_velocity),
        Note(base_tone.transposed(+7), base_duration, base_velocity),
        Note(base_tone.transposed(+10), base_duration, base_velocity),
        Note(base_tone.transposed(+14), base_duration, base_velocity),
        Note(base_tone.transposed(+17), base_duration, base_velocity)
    )
