def METHOD_NAME(
    self,
    texts: list[list[TranslateApproval]],
    src_lang: Language,
    target_lang: Language,
    *,
    tag_handling: str = "",
) -> list[str]:
    """
    Reverse the translatable text given.
    NOTE The algorithm here for combining translation results back to
    original structure might be integrated into the actual
    TranslationService-implementation.
    Note This implementation does not fully follow the needed interface.
    :return:
    :param texts: Texts to reverse
    :param src_lang: Any.
    :param target_lang: Only REVERSE_LANG["lang_code"] is supported.
    :param tag_handling: tags to intelligently handle during translation
     TODO XML-handling.
    :return: Texts where translatable ones have been reversed.
    """
    if target_lang.lang_code.lower() != REVERSE_LANG["lang_code"].lower():
        raise Exception(
            f"Bad target language. Expected '{REVERSE_LANG['lang_code']}', got '{target_lang}'."
        )
    # Iterate the blocks of texts
    translation_subjects: list[list[str]] = list()
    for xs in texts:
        # Leave non-translatable values out of the call to machine
        # translation and pick their string-valued texts to a list.
        just_translates: list[str] = list(
            map(
                lambda y: y.text,
                filter(lambda x: isinstance(x, Translate), xs),
            )
        )
        translation_subjects.append(just_translates)
    # Perform the translation on all or maximum amount of blocks at a time.
    for i, ys in enumerate(translation_subjects):
        translation_subjects[i] = self._translate(ys)
    # Insert translated parts back into their original objects.
    # NOTE This only works, if self._translate returns the values in the
    # same order as it got them!!
    for text, translated_text in zip(texts, translation_subjects):
        i = 0
        for part in text:
            if isinstance(part, Translate):
                part.text = translated_text[i]
                i += 1
    # Concatenate the strings inside texts' list of items together.
    return ["".join(map(lambda x: x.text, xs)) for xs in texts]