"""This file was generated by xsdata, v25.4, on 2025-05-13 09:06:38

Generator: PydanticGenerator
See: https://xsdata.readthedocs.io/
"""

from enum import Enum
from typing import ForwardRef, Optional, Union

from pydantic import BaseModel, ConfigDict
from xsdata_pydantic.fields import field

from pyosis.generated.xml import (
    LangValue,
    SpaceValue,
)

__NAMESPACE__ = "http://www.bibletechnologies.net/2003/OSIS/namespace"


class Calendar(Enum):
    CHINESE = "Chinese"
    GREGORIAN = "Gregorian"
    ISLAMIC = "Islamic"
    ISO = "ISO"
    JEWISH = "Jewish"
    JULIAN = "Julian"


class MilestoneSe(Enum):
    ABBR = "abbr"
    CHAPTER = "chapter"
    CLOSER = "closer"
    DIV = "div"
    FOREIGN = "foreign"
    L = "l"
    LG = "lg"
    Q = "q"
    SALUTE = "salute"
    SEG = "seg"
    SIGNED = "signed"
    SPEECH = "speech"
    VERSE = "verse"


class Milestoneable(BaseModel):
    class Meta:
        name = "milestoneable"

    model_config = ConfigDict(defer_build=True)
    s_id: Optional[str] = field(
        default=None,
        metadata={
            "name": "sID",
            "type": "Attribute",
        },
    )
    e_id: Optional[str] = field(
        default=None,
        metadata={
            "name": "eID",
            "type": "Attribute",
        },
    )


class OsisAnnotation(Enum):
    COMMENTARY = "commentary"
    EXPOSITION = "exposition"
    MEDITATION = "meditation"
    OUTLINE = "outline"
    REBUTTAL = "rebuttal"
    SERMON = "sermon"
    STUDY_GUIDE = "studyGuide"
    TRANSLATION = "translation"


class OsisCellAlign(Enum):
    LEFT = "left"
    RIGHT = "right"
    CENTER = "center"
    JUSTIFY = "justify"
    START = "start"
    END = "end"


class OsisChanges(Enum):
    ADDED = "added"
    AMPLIFIED = "amplified"
    CHANGED = "changed"
    DELETED = "deleted"
    IMPLIED = "implied"
    MOVED = "moved"
    TENSE_CHANGE = "tenseChange"


class OsisDescription(Enum):
    USFM = "usfm"


class OsisDivs(Enum):
    ACKNOWLEDGEMENT = "acknowledgement"
    AFTERWORD = "afterword"
    ANNOTANT = "annotant"
    APPENDIX = "appendix"
    ARTICLE = "article"
    BACK = "back"
    BIBLIOGRAPHY = "bibliography"
    BODY = "body"
    BOOK = "book"
    BOOK_GROUP = "bookGroup"
    BRIDGE = "bridge"
    CHAPTER = "chapter"
    COLOPHON = "colophon"
    COMMENTARY = "commentary"
    CONCORDANCE = "concordance"
    COVER_PAGE = "coverPage"
    DEDICATION = "dedication"
    DEVOTIONAL = "devotional"
    ENTRY = "entry"
    FRONT = "front"
    GAZETTEER = "gazetteer"
    GLOSSARY = "glossary"
    IMPRIMATUR = "imprimatur"
    INDEX = "index"
    INTRODUCTION = "introduction"
    MAJOR_SECTION = "majorSection"
    MAP = "map"
    OUTLINE = "outline"
    PARAGRAPH = "paragraph"
    PART = "part"
    PREFACE = "preface"
    PUBLICATION_DATA = "publicationData"
    SECTION = "section"
    SUB_SECTION = "subSection"
    SUMMARY = "summary"
    TABLEOF_CONTENTS = "tableofContents"
    TITLE_PAGE = "titlePage"


class OsisEvents(Enum):
    EDITION = "edition"
    EVERSION = "eversion"
    IMPRINT = "imprint"
    ORIGINAL = "original"


class OsisHi(Enum):
    ACROSTIC = "acrostic"
    BOLD = "bold"
    EMPHASIS = "emphasis"
    ILLUMINATED = "illuminated"
    ITALIC = "italic"
    LINE_THROUGH = "line-through"
    NORMAL = "normal"
    SMALL_CAPS = "small-caps"
    SUB = "sub"
    SUPER = "super"
    UNDERLINE = "underline"


class OsisIdentifier(Enum):
    DEWEY = "Dewey"
    DOI = "DOI"
    ISBN = "ISBN"
    ISSN = "ISSN"
    LCCN = "LCCN"
    OSIS = "OSIS"
    SICI = "SICI"
    URI = "URI"
    URL = "URL"
    URN = "URN"


class OsisLanguage(Enum):
    IANA = "IANA"
    IETF = "IETF"
    ISO_639_1 = "ISO-639-1"
    ISO_639_2 = "ISO-639-2"
    ISO_639_2_B = "ISO-639-2-B"
    ISO_639_2_T = "ISO-639-2-T"
    LINGUIST = "LINGUIST"
    OTHER = "other"
    SIL = "SIL"


class OsisLanguageUsage(Enum):
    BASE = "base"
    DIDACTIC = "didactic"
    INTERLINEAR = "interlinear"
    ORIGINAL = "original"
    QUOTATION = "quotation"
    SOURCE = "source"
    TARGET = "target"
    TRANSLATION = "translation"


class OsisLine(Enum):
    REFRAIN = "refrain"
    DOXOLOGY = "doxology"
    SELAH = "selah"
    ATTRIBUTION = "attribution"


class OsisMilestonePt(Enum):
    COLUMN = "column"
    C_QUOTE = "cQuote"
    FOOTER = "footer"
    HALF_LINE = "halfLine"
    HEADER = "header"
    LINE = "line"
    PB = "pb"
    SCREEN = "screen"


class OsisNames(Enum):
    GEOGRAPHIC = "geographic"
    HOLIDAY = "holiday"
    NONHUMAN = "nonhuman"
    PERSON = "person"
    RITUAL = "ritual"


class OsisNotes(Enum):
    ALLUSION = "allusion"
    ALTERNATIVE = "alternative"
    BACKGROUND = "background"
    CITATION = "citation"
    CROSS_REFERENCE = "crossReference"
    DEVOTIONAL = "devotional"
    ENCODER = "encoder"
    EXEGESIS = "exegesis"
    EXPLANATION = "explanation"
    LITURGICAL = "liturgical"
    SPEAKER = "speaker"
    STUDY = "study"
    TRANSLATION = "translation"
    VARIANT = "variant"


class OsisPlacementNote(Enum):
    FOOT = "foot"
    END = "end"
    INLINE = "inline"
    LEFT = "left"
    RIGHT = "right"
    INTERLINEAR = "interlinear"
    APPARATUS = "apparatus"


class OsisPlacementTitle(Enum):
    LEFT_HEAD = "leftHead"
    CENTER_HEAD = "centerHead"
    RIGHT_HEAD = "rightHead"
    INSIDE_HEAD = "insideHead"
    OUTSIDE_HEAD = "outsideHead"
    LEFT_FOOT = "leftFoot"
    CENTER_FOOT = "centerFoot"
    RIGHT_FOOT = "rightFoot"
    INSIDE_FOOT = "insideFoot"
    OUTSIDE_FOOT = "outsideFoot"


class OsisQuotes(Enum):
    BLOCK = "block"
    CITATION = "citation"
    EMBEDDED = "embedded"


class OsisRdg(Enum):
    ALTERNATE = "alternate"
    VARIANT = "variant"


class OsisReferences(Enum):
    ANNOTATE_REF = "annotateRef"
    PARALLEL = "parallel"
    SOURCE = "source"


class OsisRoles(Enum):
    ADP = "adp"
    ANN = "ann"
    ART = "art"
    AUT = "aut"
    AQT = "aqt"
    AFT = "aft"
    AUI = "aui"
    BND = "bnd"
    BDD = "bdd"
    BKD = "bkd"
    BKP = "bkp"
    BJD = "bjd"
    BPD = "bpd"
    CTG = "ctg"
    CLB = "clb"
    CMM = "cmm"
    CWT = "cwt"
    COM = "com"
    CTB = "ctb"
    CRE = "cre"
    EDT = "edt"
    ENCODER = "encoder"
    ILU = "ilu"
    ILL = "ill"
    PBL = "pbl"
    TRL = "trl"


class OsisSegs(Enum):
    ALLUDED = "alluded"
    KEYWORD = "keyword"
    OT_PASSAGE = "otPassage"
    VERSE_NUMBER = "verseNumber"


class OsisSubjects(Enum):
    ATLA = "ATLA"
    BILDI = "BILDI"
    DBC = "DBC"
    DDC = "DDC"
    EUT = "EUT"
    FGT = "FGT"
    LCC = "LCC"
    LCSH = "LCSH"
    ME_SH = "MeSH"
    NLSH = "NLSH"
    RSWK = "RSWK"
    SEARS = "SEARS"
    SOG = "SOG"
    SWD_RSWK = "SWD_RSWK"
    UDC = "UDC"
    VAT = "VAT"


class OsisTitles(Enum):
    ACROSTIC = "acrostic"
    CHAPTER = "chapter"
    CONTINUED = "continued"
    MAIN = "main"
    PARALLEL = "parallel"
    PSALM = "psalm"
    RUNNING_HEAD = "runningHead"
    SCOPE = "scope"
    SUB = "sub"


class OsisType(Enum):
    OSIS = "OSIS"


class TableRole(Enum):
    LABEL = "label"
    DATA = "data"


class TeiHeaderCt(BaseModel):
    class Meta:
        name = "teiHeaderCT"

    model_config = ConfigDict(defer_build=True)
    teiform: str = field(
        const=True,
        default="teiHeader",
        metadata={
            "name": "TEIform",
            "type": "Attribute",
        },
    )
    content: list[object] = field(
        default_factory=list,
        metadata={
            "type": "Wildcard",
            "namespace": "##any",
            "mixed": True,
        },
    )


class ContributorCt(BaseModel):
    class Meta:
        name = "contributorCT"

    model_config = ConfigDict(defer_build=True)
    value: str = field(
        default="",
        metadata={
            "required": True,
        },
    )
    canonical: Optional[bool] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    file_as: Optional[str] = field(
        default=None,
        metadata={
            "name": "file-as",
            "type": "Attribute",
        },
    )
    role: Optional[Union[OsisRoles, str]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_work: Optional[str] = field(
        default=None,
        metadata={
            "name": "annotateWork",
            "type": "Attribute",
        },
    )
    annotate_type: Optional[Union[OsisAnnotation, str]] = field(
        default=None,
        metadata={
            "name": "annotateType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    editions: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "tokens": True,
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    resp: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    type_value: Optional[str] = field(
        default=None,
        metadata={
            "name": "type",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    n: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lang: Optional[Union[str, LangValue]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    space: Optional[SpaceValue] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    script: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"([A-Z][a-z]{3}|x-[A-Za-z0-9]+)",
        },
    )


class CoverageCt(BaseModel):
    class Meta:
        name = "coverageCT"

    model_config = ConfigDict(defer_build=True)
    value: str = field(
        default="",
        metadata={
            "required": True,
        },
    )
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_work: Optional[str] = field(
        default=None,
        metadata={
            "name": "annotateWork",
            "type": "Attribute",
        },
    )
    annotate_type: Optional[Union[OsisAnnotation, str]] = field(
        default=None,
        metadata={
            "name": "annotateType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    editions: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "tokens": True,
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    resp: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    type_value: Optional[str] = field(
        default=None,
        metadata={
            "name": "type",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    n: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lang: Optional[Union[str, LangValue]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    space: Optional[SpaceValue] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    script: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"([A-Z][a-z]{3}|x-[A-Za-z0-9]+)",
        },
    )
    canonical: Optional[bool] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )


class CreatorCt(BaseModel):
    class Meta:
        name = "creatorCT"

    model_config = ConfigDict(defer_build=True)
    value: str = field(
        default="",
        metadata={
            "required": True,
        },
    )
    role: Optional[Union[OsisRoles, str]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_work: Optional[str] = field(
        default=None,
        metadata={
            "name": "annotateWork",
            "type": "Attribute",
        },
    )
    annotate_type: Optional[Union[OsisAnnotation, str]] = field(
        default=None,
        metadata={
            "name": "annotateType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    editions: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "tokens": True,
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    resp: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    type_value: Optional[str] = field(
        default=None,
        metadata={
            "name": "type",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    n: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lang: Optional[Union[str, LangValue]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    space: Optional[SpaceValue] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    script: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"([A-Z][a-z]{3}|x-[A-Za-z0-9]+)",
        },
    )
    canonical: Optional[bool] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )


class DescriptionCt(BaseModel):
    class Meta:
        name = "descriptionCT"

    model_config = ConfigDict(defer_build=True)
    value: str = field(
        default="",
        metadata={
            "required": True,
        },
    )
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_work: Optional[str] = field(
        default=None,
        metadata={
            "name": "annotateWork",
            "type": "Attribute",
        },
    )
    annotate_type: Optional[Union[OsisAnnotation, str]] = field(
        default=None,
        metadata={
            "name": "annotateType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    editions: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "tokens": True,
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    resp: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    n: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lang: Optional[Union[str, LangValue]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    space: Optional[SpaceValue] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    script: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"([A-Z][a-z]{3}|x-[A-Za-z0-9]+)",
        },
    )
    type_value: Optional[Union[OsisDescription, str]] = field(
        default=None,
        metadata={
            "name": "type",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    canonical: Optional[bool] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )


class FormatCt(BaseModel):
    class Meta:
        name = "formatCT"

    model_config = ConfigDict(defer_build=True)
    value: str = field(
        default="",
        metadata={
            "required": True,
        },
    )
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_work: Optional[str] = field(
        default=None,
        metadata={
            "name": "annotateWork",
            "type": "Attribute",
        },
    )
    annotate_type: Optional[Union[OsisAnnotation, str]] = field(
        default=None,
        metadata={
            "name": "annotateType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    editions: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "tokens": True,
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    resp: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    type_value: Optional[str] = field(
        default=None,
        metadata={
            "name": "type",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    n: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lang: Optional[Union[str, LangValue]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    space: Optional[SpaceValue] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    script: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"([A-Z][a-z]{3}|x-[A-Za-z0-9]+)",
        },
    )
    canonical: Optional[bool] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )


class IdentifierCt(BaseModel):
    class Meta:
        name = "identifierCT"

    model_config = ConfigDict(defer_build=True)
    value: str = field(
        default="",
        metadata={
            "required": True,
        },
    )
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_work: Optional[str] = field(
        default=None,
        metadata={
            "name": "annotateWork",
            "type": "Attribute",
        },
    )
    annotate_type: Optional[Union[OsisAnnotation, str]] = field(
        default=None,
        metadata={
            "name": "annotateType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    editions: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "tokens": True,
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    resp: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    n: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lang: Optional[Union[str, LangValue]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    space: Optional[SpaceValue] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    script: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"([A-Z][a-z]{3}|x-[A-Za-z0-9]+)",
        },
    )
    type_value: Optional[Union[OsisIdentifier, str]] = field(
        default=None,
        metadata={
            "name": "type",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    canonical: Optional[bool] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )


class IndexCt(BaseModel):
    class Meta:
        name = "indexCT"

    model_config = ConfigDict(defer_build=True)
    canonical: Optional[bool] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    index: str = field(
        metadata={
            "type": "Attribute",
            "required": True,
        }
    )
    level1: str = field(
        metadata={
            "type": "Attribute",
            "required": True,
        }
    )
    level2: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    level3: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    level4: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    see: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_work: Optional[str] = field(
        default=None,
        metadata={
            "name": "annotateWork",
            "type": "Attribute",
        },
    )
    annotate_type: Optional[Union[OsisAnnotation, str]] = field(
        default=None,
        metadata={
            "name": "annotateType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    editions: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "tokens": True,
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    resp: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    type_value: Optional[str] = field(
        default=None,
        metadata={
            "name": "type",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    n: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lang: Optional[Union[str, LangValue]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    space: Optional[SpaceValue] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    script: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"([A-Z][a-z]{3}|x-[A-Za-z0-9]+)",
        },
    )
    teiform: str = field(
        const=True,
        default="index",
        metadata={
            "name": "TEIform",
            "type": "Attribute",
        },
    )


class LanguageCt(BaseModel):
    class Meta:
        name = "languageCT"

    model_config = ConfigDict(defer_build=True)
    value: str = field(
        default="",
        metadata={
            "required": True,
        },
    )
    type_value: Optional[Union[OsisLanguage, str]] = field(
        default=None,
        metadata={
            "name": "type",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    use: Optional[Union[OsisLanguageUsage, str]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_work: Optional[str] = field(
        default=None,
        metadata={
            "name": "annotateWork",
            "type": "Attribute",
        },
    )
    annotate_type: Optional[Union[OsisAnnotation, str]] = field(
        default=None,
        metadata={
            "name": "annotateType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    editions: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "tokens": True,
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    resp: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    n: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lang: Optional[Union[str, LangValue]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    space: Optional[SpaceValue] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    script: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"([A-Z][a-z]{3}|x-[A-Za-z0-9]+)",
        },
    )
    canonical: Optional[bool] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )


class LbCt(BaseModel):
    class Meta:
        name = "lbCT"

    model_config = ConfigDict(defer_build=True)
    canonical: Optional[bool] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_work: Optional[str] = field(
        default=None,
        metadata={
            "name": "annotateWork",
            "type": "Attribute",
        },
    )
    annotate_type: Optional[Union[OsisAnnotation, str]] = field(
        default=None,
        metadata={
            "name": "annotateType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    editions: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "tokens": True,
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    resp: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    type_value: Optional[str] = field(
        default=None,
        metadata={
            "name": "type",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    n: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lang: Optional[Union[str, LangValue]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    space: Optional[SpaceValue] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    script: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"([A-Z][a-z]{3}|x-[A-Za-z0-9]+)",
        },
    )
    teiform: str = field(
        const=True,
        default="milestone",
        metadata={
            "name": "TEIform",
            "type": "Attribute",
        },
    )


class MilestoneCt(BaseModel):
    class Meta:
        name = "milestoneCT"

    model_config = ConfigDict(defer_build=True)
    canonical: Optional[bool] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    type_value: Optional[Union[OsisMilestonePt, str]] = field(
        default=None,
        metadata={
            "name": "type",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_work: Optional[str] = field(
        default=None,
        metadata={
            "name": "annotateWork",
            "type": "Attribute",
        },
    )
    annotate_type: Optional[Union[OsisAnnotation, str]] = field(
        default=None,
        metadata={
            "name": "annotateType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    editions: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "tokens": True,
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    resp: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    n: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lang: Optional[Union[str, LangValue]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    space: Optional[SpaceValue] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    script: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"([A-Z][a-z]{3}|x-[A-Za-z0-9]+)",
        },
    )
    marker: str = field(
        default="DEFAULT",
        metadata={
            "type": "Attribute",
        },
    )
    teiform: str = field(
        const=True,
        default="milestone",
        metadata={
            "name": "TEIform",
            "type": "Attribute",
        },
    )


class MilestoneEndCt(BaseModel):
    class Meta:
        name = "milestoneEndCT"

    model_config = ConfigDict(defer_build=True)
    canonical: Optional[bool] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    type_value: Optional[MilestoneSe] = field(
        default=None,
        metadata={
            "name": "type",
            "type": "Attribute",
        },
    )
    start: str = field(
        metadata={
            "type": "Attribute",
            "required": True,
        }
    )
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_work: Optional[str] = field(
        default=None,
        metadata={
            "name": "annotateWork",
            "type": "Attribute",
        },
    )
    annotate_type: Optional[Union[OsisAnnotation, str]] = field(
        default=None,
        metadata={
            "name": "annotateType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    editions: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "tokens": True,
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    resp: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    n: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lang: Optional[Union[str, LangValue]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    space: Optional[SpaceValue] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    script: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"([A-Z][a-z]{3}|x-[A-Za-z0-9]+)",
        },
    )
    teiform: str = field(
        const=True,
        default="milestone",
        metadata={
            "name": "TEIform",
            "type": "Attribute",
        },
    )


class MilestoneStartCt(BaseModel):
    class Meta:
        name = "milestoneStartCT"

    model_config = ConfigDict(defer_build=True)
    canonical: Optional[bool] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    end: str = field(
        metadata={
            "type": "Attribute",
            "required": True,
        }
    )
    type_value: Optional[MilestoneSe] = field(
        default=None,
        metadata={
            "name": "type",
            "type": "Attribute",
        },
    )
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_work: Optional[str] = field(
        default=None,
        metadata={
            "name": "annotateWork",
            "type": "Attribute",
        },
    )
    annotate_type: Optional[Union[OsisAnnotation, str]] = field(
        default=None,
        metadata={
            "name": "annotateType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    editions: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "tokens": True,
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    resp: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    n: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lang: Optional[Union[str, LangValue]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    space: Optional[SpaceValue] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    script: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"([A-Z][a-z]{3}|x-[A-Za-z0-9]+)",
        },
    )
    teiform: str = field(
        const=True,
        default="milestone",
        metadata={
            "name": "TEIform",
            "type": "Attribute",
        },
    )


class PublisherCt(BaseModel):
    class Meta:
        name = "publisherCT"

    model_config = ConfigDict(defer_build=True)
    value: str = field(
        default="",
        metadata={
            "required": True,
        },
    )
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_work: Optional[str] = field(
        default=None,
        metadata={
            "name": "annotateWork",
            "type": "Attribute",
        },
    )
    annotate_type: Optional[Union[OsisAnnotation, str]] = field(
        default=None,
        metadata={
            "name": "annotateType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    editions: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "tokens": True,
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    resp: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    type_value: Optional[str] = field(
        default=None,
        metadata={
            "name": "type",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    n: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lang: Optional[Union[str, LangValue]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    space: Optional[SpaceValue] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    script: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"([A-Z][a-z]{3}|x-[A-Za-z0-9]+)",
        },
    )
    canonical: Optional[bool] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )


class RefSystemCt(BaseModel):
    class Meta:
        name = "refSystemCT"

    model_config = ConfigDict(defer_build=True)
    value: str = field(
        default="",
        metadata={
            "required": True,
        },
    )
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_work: Optional[str] = field(
        default=None,
        metadata={
            "name": "annotateWork",
            "type": "Attribute",
        },
    )
    annotate_type: Optional[Union[OsisAnnotation, str]] = field(
        default=None,
        metadata={
            "name": "annotateType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    editions: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "tokens": True,
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    resp: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    type_value: Optional[str] = field(
        default=None,
        metadata={
            "name": "type",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    n: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lang: Optional[Union[str, LangValue]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    space: Optional[SpaceValue] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    script: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"([A-Z][a-z]{3}|x-[A-Za-z0-9]+)",
        },
    )
    canonical: Optional[bool] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )


class RelationCt(BaseModel):
    class Meta:
        name = "relationCT"

    model_config = ConfigDict(defer_build=True)
    value: str = field(
        default="",
        metadata={
            "required": True,
        },
    )
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_work: Optional[str] = field(
        default=None,
        metadata={
            "name": "annotateWork",
            "type": "Attribute",
        },
    )
    annotate_type: Optional[Union[OsisAnnotation, str]] = field(
        default=None,
        metadata={
            "name": "annotateType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    editions: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "tokens": True,
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    resp: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    type_value: Optional[str] = field(
        default=None,
        metadata={
            "name": "type",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    n: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lang: Optional[Union[str, LangValue]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    space: Optional[SpaceValue] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    script: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"([A-Z][a-z]{3}|x-[A-Za-z0-9]+)",
        },
    )
    canonical: Optional[bool] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )


class RightsCt(BaseModel):
    class Meta:
        name = "rightsCT"

    model_config = ConfigDict(defer_build=True)
    value: str = field(
        default="",
        metadata={
            "required": True,
        },
    )
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_work: Optional[str] = field(
        default=None,
        metadata={
            "name": "annotateWork",
            "type": "Attribute",
        },
    )
    annotate_type: Optional[Union[OsisAnnotation, str]] = field(
        default=None,
        metadata={
            "name": "annotateType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    editions: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "tokens": True,
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    resp: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    type_value: Optional[str] = field(
        default=None,
        metadata={
            "name": "type",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    n: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lang: Optional[Union[str, LangValue]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    space: Optional[SpaceValue] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    script: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"([A-Z][a-z]{3}|x-[A-Za-z0-9]+)",
        },
    )
    canonical: Optional[bool] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )


class ScopeCt(BaseModel):
    class Meta:
        name = "scopeCT"

    model_config = ConfigDict(defer_build=True)
    value: list[str] = field(
        default_factory=list,
        metadata={
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    canonical: Optional[bool] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_work: Optional[str] = field(
        default=None,
        metadata={
            "name": "annotateWork",
            "type": "Attribute",
        },
    )
    annotate_type: Optional[Union[OsisAnnotation, str]] = field(
        default=None,
        metadata={
            "name": "annotateType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    editions: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "tokens": True,
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    resp: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    type_value: Optional[str] = field(
        default=None,
        metadata={
            "name": "type",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    n: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lang: Optional[Union[str, LangValue]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    space: Optional[SpaceValue] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    script: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"([A-Z][a-z]{3}|x-[A-Za-z0-9]+)",
        },
    )


class SourceCt(BaseModel):
    class Meta:
        name = "sourceCT"

    model_config = ConfigDict(defer_build=True)
    value: str = field(
        default="",
        metadata={
            "required": True,
        },
    )
    canonical: Optional[bool] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_work: Optional[str] = field(
        default=None,
        metadata={
            "name": "annotateWork",
            "type": "Attribute",
        },
    )
    annotate_type: Optional[Union[OsisAnnotation, str]] = field(
        default=None,
        metadata={
            "name": "annotateType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    editions: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "tokens": True,
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    resp: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    type_value: Optional[str] = field(
        default=None,
        metadata={
            "name": "type",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    n: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lang: Optional[Union[str, LangValue]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    space: Optional[SpaceValue] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    script: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"([A-Z][a-z]{3}|x-[A-Za-z0-9]+)",
        },
    )


class SubjectCt(BaseModel):
    class Meta:
        name = "subjectCT"

    model_config = ConfigDict(defer_build=True)
    value: str = field(
        default="",
        metadata={
            "required": True,
        },
    )
    canonical: Optional[bool] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    type_value: Optional[Union[OsisSubjects, str]] = field(
        default=None,
        metadata={
            "name": "type",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_work: Optional[str] = field(
        default=None,
        metadata={
            "name": "annotateWork",
            "type": "Attribute",
        },
    )
    annotate_type: Optional[Union[OsisAnnotation, str]] = field(
        default=None,
        metadata={
            "name": "annotateType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    editions: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "tokens": True,
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    resp: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    n: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lang: Optional[Union[str, LangValue]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    space: Optional[SpaceValue] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    script: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"([A-Z][a-z]{3}|x-[A-Za-z0-9]+)",
        },
    )


class TypeCt(BaseModel):
    class Meta:
        name = "typeCT"

    model_config = ConfigDict(defer_build=True)
    value: str = field(
        default="",
        metadata={
            "required": True,
        },
    )
    canonical: Optional[bool] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    type_value: Optional[Union[OsisType, str]] = field(
        default=None,
        metadata={
            "name": "type",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_work: Optional[str] = field(
        default=None,
        metadata={
            "name": "annotateWork",
            "type": "Attribute",
        },
    )
    annotate_type: Optional[Union[OsisAnnotation, str]] = field(
        default=None,
        metadata={
            "name": "annotateType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    editions: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "tokens": True,
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    resp: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    n: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lang: Optional[Union[str, LangValue]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    space: Optional[SpaceValue] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    script: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"([A-Z][a-z]{3}|x-[A-Za-z0-9]+)",
        },
    )


class WorkPrefixCt(BaseModel):
    class Meta:
        name = "workPrefixCT"

    model_config = ConfigDict(defer_build=True)
    path: str = field(
        metadata={
            "type": "Attribute",
            "required": True,
            "pattern": r"((//((\p{L}|\p{N}|_|-|\.|:)+))(/(\p{L}|\p{N}|_|-|\.|:)+)?(/@(\p{L}|\p{N}|_|-|\.|:)+))",
        }
    )
    osis_work: str = field(
        metadata={
            "name": "osisWork",
            "type": "Attribute",
            "required": True,
            "pattern": r"((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?",
        }
    )
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_work: Optional[str] = field(
        default=None,
        metadata={
            "name": "annotateWork",
            "type": "Attribute",
        },
    )
    annotate_type: Optional[Union[OsisAnnotation, str]] = field(
        default=None,
        metadata={
            "name": "annotateType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    editions: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "tokens": True,
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    resp: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    n: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lang: Optional[Union[str, LangValue]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    space: Optional[SpaceValue] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    script: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"([A-Z][a-z]{3}|x-[A-Za-z0-9]+)",
        },
    )


class ACt(BaseModel):
    class Meta:
        name = "aCT"

    model_config = ConfigDict(defer_build=True)
    canonical: Optional[bool] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    href: str = field(
        metadata={
            "type": "Attribute",
            "required": True,
        }
    )
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_work: Optional[str] = field(
        default=None,
        metadata={
            "name": "annotateWork",
            "type": "Attribute",
        },
    )
    annotate_type: Optional[Union[OsisAnnotation, str]] = field(
        default=None,
        metadata={
            "name": "annotateType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    editions: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "tokens": True,
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    resp: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    type_value: Optional[str] = field(
        default=None,
        metadata={
            "name": "type",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    n: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lang: Optional[Union[str, LangValue]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    space: Optional[SpaceValue] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    script: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"([A-Z][a-z]{3}|x-[A-Za-z0-9]+)",
        },
    )
    content: list[object] = field(
        default_factory=list,
        metadata={
            "type": "Wildcard",
            "namespace": "##any",
            "mixed": True,
            "choices": (
                {
                    "name": "index",
                    "type": IndexCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
            ),
        },
    )


class AbbrCt(Milestoneable):
    class Meta:
        name = "abbrCT"

    model_config = ConfigDict(defer_build=True)
    canonical: Optional[bool] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    expansion: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_work: Optional[str] = field(
        default=None,
        metadata={
            "name": "annotateWork",
            "type": "Attribute",
        },
    )
    annotate_type: Optional[Union[OsisAnnotation, str]] = field(
        default=None,
        metadata={
            "name": "annotateType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    editions: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "tokens": True,
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    resp: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    type_value: Optional[str] = field(
        default=None,
        metadata={
            "name": "type",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    n: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lang: Optional[Union[str, LangValue]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    space: Optional[SpaceValue] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    script: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"([A-Z][a-z]{3}|x-[A-Za-z0-9]+)",
        },
    )
    teiform: str = field(
        const=True,
        default="abbr",
        metadata={
            "name": "TEIform",
            "type": "Attribute",
        },
    )
    content: list[object] = field(
        default_factory=list,
        metadata={
            "type": "Wildcard",
            "namespace": "##any",
            "mixed": True,
            "choices": (
                {
                    "name": "a",
                    "type": ACt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "divineName",
                    "type": ForwardRef("DivineNameCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "foreign",
                    "type": ForwardRef("ForeignCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "index",
                    "type": IndexCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "name",
                    "type": ForwardRef("NameCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "note",
                    "type": ForwardRef("NoteCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "reference",
                    "type": ForwardRef("ReferenceCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "w",
                    "type": ForwardRef("WCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
            ),
        },
    )


class DateCt(BaseModel):
    class Meta:
        name = "dateCT"

    model_config = ConfigDict(defer_build=True)
    canonical: Optional[bool] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    event: Optional[Union[OsisEvents, str]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    type_value: Calendar = field(
        default=Calendar.ISO,
        metadata={
            "name": "type",
            "type": "Attribute",
        },
    )
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_work: Optional[str] = field(
        default=None,
        metadata={
            "name": "annotateWork",
            "type": "Attribute",
        },
    )
    annotate_type: Optional[Union[OsisAnnotation, str]] = field(
        default=None,
        metadata={
            "name": "annotateType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    editions: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "tokens": True,
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    resp: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    n: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lang: Optional[Union[str, LangValue]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    space: Optional[SpaceValue] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    script: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"([A-Z][a-z]{3}|x-[A-Za-z0-9]+)",
        },
    )
    teiform: str = field(
        const=True,
        default="date",
        metadata={
            "name": "TEIform",
            "type": "Attribute",
        },
    )
    content: list[object] = field(
        default_factory=list,
        metadata={
            "type": "Wildcard",
            "namespace": "##any",
            "mixed": True,
            "choices": (
                {
                    "name": "a",
                    "type": ACt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "index",
                    "type": IndexCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "note",
                    "type": ForwardRef("NoteCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "w",
                    "type": ForwardRef("WCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
            ),
        },
    )


class CaptionCt(BaseModel):
    class Meta:
        name = "captionCT"

    model_config = ConfigDict(defer_build=True)
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_work: Optional[str] = field(
        default=None,
        metadata={
            "name": "annotateWork",
            "type": "Attribute",
        },
    )
    annotate_type: Optional[Union[OsisAnnotation, str]] = field(
        default=None,
        metadata={
            "name": "annotateType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    editions: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "tokens": True,
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    resp: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    type_value: Optional[str] = field(
        default=None,
        metadata={
            "name": "type",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    n: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lang: Optional[Union[str, LangValue]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    space: Optional[SpaceValue] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    script: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"([A-Z][a-z]{3}|x-[A-Za-z0-9]+)",
        },
    )
    canonical: Optional[bool] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    teiform: str = field(
        const=True,
        default="figDesc",
        metadata={
            "name": "TEIform",
            "type": "Attribute",
        },
    )
    content: list[object] = field(
        default_factory=list,
        metadata={
            "type": "Wildcard",
            "namespace": "##any",
            "mixed": True,
            "choices": (
                {
                    "name": "a",
                    "type": ACt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "abbr",
                    "type": AbbrCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "date",
                    "type": ForwardRef("DateCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "divineName",
                    "type": ForwardRef("DivineNameCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "foreign",
                    "type": ForwardRef("ForeignCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "hi",
                    "type": ForwardRef("HiCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "index",
                    "type": IndexCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "lb",
                    "type": LbCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestone",
                    "type": MilestoneCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "name",
                    "type": ForwardRef("NameCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "note",
                    "type": ForwardRef("NoteCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "q",
                    "type": ForwardRef("QCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "reference",
                    "type": ForwardRef("ReferenceCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "seg",
                    "type": ForwardRef("SegCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "w",
                    "type": ForwardRef("WCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
            ),
        },
    )


class CatchWordCt(BaseModel):
    class Meta:
        name = "catchWordCT"

    model_config = ConfigDict(defer_build=True)
    canonical: Optional[bool] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    osis_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_work: Optional[str] = field(
        default=None,
        metadata={
            "name": "annotateWork",
            "type": "Attribute",
        },
    )
    annotate_type: Optional[Union[OsisAnnotation, str]] = field(
        default=None,
        metadata={
            "name": "annotateType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    editions: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "tokens": True,
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    resp: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    type_value: Optional[str] = field(
        default=None,
        metadata={
            "name": "type",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    n: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lang: Optional[Union[str, LangValue]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    space: Optional[SpaceValue] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    script: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"([A-Z][a-z]{3}|x-[A-Za-z0-9]+)",
        },
    )
    content: list[object] = field(
        default_factory=list,
        metadata={
            "type": "Wildcard",
            "namespace": "##any",
            "mixed": True,
            "choices": (
                {
                    "name": "a",
                    "type": ACt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "abbr",
                    "type": AbbrCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "date",
                    "type": ForwardRef("DateCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "divineName",
                    "type": ForwardRef("DivineNameCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "foreign",
                    "type": ForwardRef("ForeignCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "hi",
                    "type": ForwardRef("HiCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "index",
                    "type": IndexCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "inscription",
                    "type": ForwardRef("InscriptionCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "lb",
                    "type": LbCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "list",
                    "type": ForwardRef("ListCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "mentioned",
                    "type": ForwardRef("MentionedCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestone",
                    "type": MilestoneCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestoneEnd",
                    "type": MilestoneEndCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestoneStart",
                    "type": MilestoneStartCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "name",
                    "type": ForwardRef("NameCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "note",
                    "type": ForwardRef("NoteCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "q",
                    "type": ForwardRef("QCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "reference",
                    "type": ForwardRef("ReferenceCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "seg",
                    "type": ForwardRef("SegCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "speaker",
                    "type": ForwardRef("SpeakerCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "title",
                    "type": ForwardRef("TitleCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "transChange",
                    "type": ForwardRef("TransChangeCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "w",
                    "type": ForwardRef("WCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
            ),
        },
    )


class CellCt(BaseModel):
    class Meta:
        name = "cellCT"

    model_config = ConfigDict(defer_build=True)
    canonical: Optional[bool] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    role: TableRole = field(
        default=TableRole.DATA,
        metadata={
            "type": "Attribute",
        },
    )
    align: Optional[OsisCellAlign] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_work: Optional[str] = field(
        default=None,
        metadata={
            "name": "annotateWork",
            "type": "Attribute",
        },
    )
    annotate_type: Optional[Union[OsisAnnotation, str]] = field(
        default=None,
        metadata={
            "name": "annotateType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    editions: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "tokens": True,
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    resp: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    type_value: Optional[str] = field(
        default=None,
        metadata={
            "name": "type",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    n: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lang: Optional[Union[str, LangValue]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    space: Optional[SpaceValue] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    script: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"([A-Z][a-z]{3}|x-[A-Za-z0-9]+)",
        },
    )
    teiform: str = field(
        const=True,
        default="cell",
        metadata={
            "name": "TEIform",
            "type": "Attribute",
        },
    )
    content: list[object] = field(
        default_factory=list,
        metadata={
            "type": "Wildcard",
            "namespace": "##any",
            "mixed": True,
            "choices": (
                {
                    "name": "a",
                    "type": ACt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "abbr",
                    "type": AbbrCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "closer",
                    "type": ForwardRef("CloserCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "date",
                    "type": ForwardRef("DateCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "divineName",
                    "type": ForwardRef("DivineNameCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "figure",
                    "type": ForwardRef("FigureCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "foreign",
                    "type": ForwardRef("ForeignCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "hi",
                    "type": ForwardRef("HiCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "index",
                    "type": IndexCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "inscription",
                    "type": ForwardRef("InscriptionCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "lb",
                    "type": LbCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "lg",
                    "type": ForwardRef("LgCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "list",
                    "type": ForwardRef("ListCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestone",
                    "type": MilestoneCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestoneEnd",
                    "type": MilestoneEndCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestoneStart",
                    "type": MilestoneStartCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "name",
                    "type": ForwardRef("NameCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "note",
                    "type": ForwardRef("NoteCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "p",
                    "type": ForwardRef("PCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "q",
                    "type": ForwardRef("QCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "reference",
                    "type": ForwardRef("ReferenceCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "salute",
                    "type": ForwardRef("SaluteCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "seq",
                    "type": ForwardRef("SegCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "signed",
                    "type": ForwardRef("SignedCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "speaker",
                    "type": ForwardRef("SpeakerCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "speech",
                    "type": ForwardRef("SpeechCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "table",
                    "type": ForwardRef("TableCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "title",
                    "type": ForwardRef("TitleCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "transChange",
                    "type": ForwardRef("TransChangeCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "verse",
                    "type": ForwardRef("VerseCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "w",
                    "type": ForwardRef("WCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
            ),
        },
    )


class ChapterCt(Milestoneable):
    class Meta:
        name = "chapterCT"

    model_config = ConfigDict(defer_build=True)
    chapter_title: Optional[str] = field(
        default=None,
        metadata={
            "name": "chapterTitle",
            "type": "Attribute",
        },
    )
    canonical: Optional[bool] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    osis_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_work: Optional[str] = field(
        default=None,
        metadata={
            "name": "annotateWork",
            "type": "Attribute",
        },
    )
    annotate_type: Optional[Union[OsisAnnotation, str]] = field(
        default=None,
        metadata={
            "name": "annotateType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    editions: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "tokens": True,
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    resp: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    type_value: Optional[str] = field(
        default=None,
        metadata={
            "name": "type",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    n: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lang: Optional[Union[str, LangValue]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    space: Optional[SpaceValue] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    script: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"([A-Z][a-z]{3}|x-[A-Za-z0-9]+)",
        },
    )
    teiform: str = field(
        const=True,
        default="div",
        metadata={
            "name": "TEIform",
            "type": "Attribute",
        },
    )
    content: list[object] = field(
        default_factory=list,
        metadata={
            "type": "Wildcard",
            "namespace": "##any",
            "mixed": True,
            "choices": (
                {
                    "name": "a",
                    "type": ACt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "abbr",
                    "type": AbbrCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "closer",
                    "type": ForwardRef("CloserCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "date",
                    "type": ForwardRef("DateCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "div",
                    "type": ForwardRef("DivCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "divineName",
                    "type": ForwardRef("DivineNameCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "figure",
                    "type": ForwardRef("FigureCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "foreign",
                    "type": ForwardRef("ForeignCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "hi",
                    "type": ForwardRef("HiCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "index",
                    "type": IndexCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "inscription",
                    "type": ForwardRef("InscriptionCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "lb",
                    "type": LbCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "lg",
                    "type": ForwardRef("LgCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "list",
                    "type": ForwardRef("ListCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "mentioned",
                    "type": ForwardRef("MentionedCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestone",
                    "type": MilestoneCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestoneEnd",
                    "type": MilestoneEndCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestoneStart",
                    "type": MilestoneStartCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "name",
                    "type": ForwardRef("NameCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "note",
                    "type": ForwardRef("NoteCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "p",
                    "type": ForwardRef("PCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "q",
                    "type": ForwardRef("QCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "reference",
                    "type": ForwardRef("ReferenceCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "salute",
                    "type": ForwardRef("SaluteCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "seg",
                    "type": ForwardRef("SegCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "signed",
                    "type": ForwardRef("SignedCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "speaker",
                    "type": ForwardRef("SpeakerCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "speech",
                    "type": ForwardRef("SpeechCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "table",
                    "type": ForwardRef("TableCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "title",
                    "type": ForwardRef("TitleCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "transChange",
                    "type": ForwardRef("TransChangeCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "verse",
                    "type": ForwardRef("VerseCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "w",
                    "type": ForwardRef("WCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
            ),
        },
    )


class CloserCt(Milestoneable):
    class Meta:
        name = "closerCT"

    model_config = ConfigDict(defer_build=True)
    canonical: Optional[bool] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_work: Optional[str] = field(
        default=None,
        metadata={
            "name": "annotateWork",
            "type": "Attribute",
        },
    )
    annotate_type: Optional[Union[OsisAnnotation, str]] = field(
        default=None,
        metadata={
            "name": "annotateType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    editions: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "tokens": True,
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    resp: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    type_value: Optional[str] = field(
        default=None,
        metadata={
            "name": "type",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    n: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lang: Optional[Union[str, LangValue]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    space: Optional[SpaceValue] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    script: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"([A-Z][a-z]{3}|x-[A-Za-z0-9]+)",
        },
    )
    teiform: str = field(
        const=True,
        default="closer",
        metadata={
            "name": "TEIform",
            "type": "Attribute",
        },
    )
    content: list[object] = field(
        default_factory=list,
        metadata={
            "type": "Wildcard",
            "namespace": "##any",
            "mixed": True,
            "choices": (
                {
                    "name": "a",
                    "type": ACt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "abbr",
                    "type": AbbrCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "date",
                    "type": ForwardRef("DateCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "divineName",
                    "type": ForwardRef("DivineNameCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "foreign",
                    "type": ForwardRef("ForeignCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "hi",
                    "type": ForwardRef("HiCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "index",
                    "type": IndexCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "lb",
                    "type": LbCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "lg",
                    "type": ForwardRef("LgCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "list",
                    "type": ForwardRef("ListCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "mentioned",
                    "type": ForwardRef("MentionedCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestone",
                    "type": MilestoneCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestoneEnd",
                    "type": MilestoneEndCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestoneStart",
                    "type": MilestoneStartCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "name",
                    "type": ForwardRef("NameCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "note",
                    "type": ForwardRef("NoteCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "p",
                    "type": ForwardRef("PCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "q",
                    "type": ForwardRef("QCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "reference",
                    "type": ForwardRef("ReferenceCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "seg",
                    "type": ForwardRef("SegCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "signed",
                    "type": ForwardRef("SignedCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "speaker",
                    "type": ForwardRef("SpeakerCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "transChange",
                    "type": ForwardRef("TransChangeCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "verse",
                    "type": ForwardRef("VerseCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "w",
                    "type": ForwardRef("WCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
            ),
        },
    )


class DivineNameCt(BaseModel):
    class Meta:
        name = "divineNameCT"

    model_config = ConfigDict(defer_build=True)
    canonical: Optional[bool] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_work: Optional[str] = field(
        default=None,
        metadata={
            "name": "annotateWork",
            "type": "Attribute",
        },
    )
    annotate_type: Optional[Union[OsisAnnotation, str]] = field(
        default=None,
        metadata={
            "name": "annotateType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    editions: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "tokens": True,
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    resp: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    type_value: Optional[str] = field(
        default=None,
        metadata={
            "name": "type",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    n: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lang: Optional[Union[str, LangValue]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    space: Optional[SpaceValue] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    script: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"([A-Z][a-z]{3}|x-[A-Za-z0-9]+)",
        },
    )
    content: list[object] = field(
        default_factory=list,
        metadata={
            "type": "Wildcard",
            "namespace": "##any",
            "mixed": True,
            "choices": (
                {
                    "name": "a",
                    "type": ACt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "abbr",
                    "type": AbbrCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "foreign",
                    "type": ForwardRef("ForeignCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "index",
                    "type": IndexCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "note",
                    "type": ForwardRef("NoteCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "reference",
                    "type": ForwardRef("ReferenceCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "seg",
                    "type": ForwardRef("SegCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "w",
                    "type": ForwardRef("WCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
            ),
        },
    )


class FigureCt(BaseModel):
    class Meta:
        name = "figureCT"

    model_config = ConfigDict(defer_build=True)
    caption: list[CaptionCt] = field(
        default_factory=list,
        metadata={
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
        },
    )
    index: list[IndexCt] = field(
        default_factory=list,
        metadata={
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
        },
    )
    note: list["NoteCt"] = field(
        default_factory=list,
        metadata={
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
        },
    )
    reference: list["ReferenceCt"] = field(
        default_factory=list,
        metadata={
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
        },
    )
    alt: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    canonical: Optional[bool] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    catalog: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    location: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    osis_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    rights: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    size: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    src: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_work: Optional[str] = field(
        default=None,
        metadata={
            "name": "annotateWork",
            "type": "Attribute",
        },
    )
    annotate_type: Optional[Union[OsisAnnotation, str]] = field(
        default=None,
        metadata={
            "name": "annotateType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    editions: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "tokens": True,
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    resp: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    type_value: Optional[str] = field(
        default=None,
        metadata={
            "name": "type",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    n: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lang: Optional[Union[str, LangValue]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    space: Optional[SpaceValue] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    script: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"([A-Z][a-z]{3}|x-[A-Za-z0-9]+)",
        },
    )
    teiform: str = field(
        const=True,
        default="figure",
        metadata={
            "name": "TEIform",
            "type": "Attribute",
        },
    )


class ForeignCt(Milestoneable):
    class Meta:
        name = "foreignCT"

    model_config = ConfigDict(defer_build=True)
    canonical: Optional[bool] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_work: Optional[str] = field(
        default=None,
        metadata={
            "name": "annotateWork",
            "type": "Attribute",
        },
    )
    annotate_type: Optional[Union[OsisAnnotation, str]] = field(
        default=None,
        metadata={
            "name": "annotateType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    editions: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "tokens": True,
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    resp: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    type_value: Optional[str] = field(
        default=None,
        metadata={
            "name": "type",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    n: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lang: Optional[Union[str, LangValue]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    space: Optional[SpaceValue] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    script: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"([A-Z][a-z]{3}|x-[A-Za-z0-9]+)",
        },
    )
    teiform: str = field(
        const=True,
        default="foreign",
        metadata={
            "name": "TEIform",
            "type": "Attribute",
        },
    )
    content: list[object] = field(
        default_factory=list,
        metadata={
            "type": "Wildcard",
            "namespace": "##any",
            "mixed": True,
            "choices": (
                {
                    "name": "a",
                    "type": ACt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "abbr",
                    "type": AbbrCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "date",
                    "type": DateCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "divineName",
                    "type": DivineNameCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "foreign",
                    "type": ForwardRef("ForeignCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "hi",
                    "type": ForwardRef("HiCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "index",
                    "type": IndexCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "lb",
                    "type": LbCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestone",
                    "type": MilestoneCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "name",
                    "type": ForwardRef("NameCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "note",
                    "type": ForwardRef("NoteCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "reference",
                    "type": ForwardRef("ReferenceCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "seg",
                    "type": ForwardRef("SegCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "title",
                    "type": ForwardRef("TitleCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "w",
                    "type": ForwardRef("WCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
            ),
        },
    )


class RowCt(BaseModel):
    class Meta:
        name = "rowCT"

    model_config = ConfigDict(defer_build=True)
    cell: list[CellCt] = field(
        default_factory=list,
        metadata={
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
            "min_occurs": 1,
        },
    )
    canonical: Optional[bool] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    role: Optional[TableRole] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_work: Optional[str] = field(
        default=None,
        metadata={
            "name": "annotateWork",
            "type": "Attribute",
        },
    )
    annotate_type: Optional[Union[OsisAnnotation, str]] = field(
        default=None,
        metadata={
            "name": "annotateType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    editions: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "tokens": True,
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    resp: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    type_value: Optional[str] = field(
        default=None,
        metadata={
            "name": "type",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    n: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lang: Optional[Union[str, LangValue]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    space: Optional[SpaceValue] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    script: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"([A-Z][a-z]{3}|x-[A-Za-z0-9]+)",
        },
    )
    teiform: str = field(
        const=True,
        default="row",
        metadata={
            "name": "TEIform",
            "type": "Attribute",
        },
    )


class HeadCt(BaseModel):
    class Meta:
        name = "headCT"

    model_config = ConfigDict(defer_build=True)
    canonical: Optional[bool] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_work: Optional[str] = field(
        default=None,
        metadata={
            "name": "annotateWork",
            "type": "Attribute",
        },
    )
    annotate_type: Optional[Union[OsisAnnotation, str]] = field(
        default=None,
        metadata={
            "name": "annotateType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    editions: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "tokens": True,
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    resp: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    type_value: Optional[str] = field(
        default=None,
        metadata={
            "name": "type",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    n: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lang: Optional[Union[str, LangValue]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    space: Optional[SpaceValue] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    script: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"([A-Z][a-z]{3}|x-[A-Za-z0-9]+)",
        },
    )
    teiform: str = field(
        const=True,
        default="head",
        metadata={
            "name": "TEIform",
            "type": "Attribute",
        },
    )
    content: list[object] = field(
        default_factory=list,
        metadata={
            "type": "Wildcard",
            "namespace": "##any",
            "mixed": True,
            "choices": (
                {
                    "name": "a",
                    "type": ACt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "abbr",
                    "type": AbbrCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "date",
                    "type": DateCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "divineName",
                    "type": DivineNameCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "foreign",
                    "type": ForeignCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "head",
                    "type": ForwardRef("HeadCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "hi",
                    "type": ForwardRef("HiCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "index",
                    "type": IndexCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "lb",
                    "type": LbCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestone",
                    "type": MilestoneCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestoneEnd",
                    "type": MilestoneEndCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestoneStart",
                    "type": MilestoneStartCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "name",
                    "type": ForwardRef("NameCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "note",
                    "type": ForwardRef("NoteCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "q",
                    "type": ForwardRef("QCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "reference",
                    "type": ForwardRef("ReferenceCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "seg",
                    "type": ForwardRef("SegCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "w",
                    "type": ForwardRef("WCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
            ),
        },
    )


class HiCt(BaseModel):
    class Meta:
        name = "hiCT"

    model_config = ConfigDict(defer_build=True)
    canonical: Optional[bool] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    type_value: Optional[Union[OsisHi, str]] = field(
        default=None,
        metadata={
            "name": "type",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_work: Optional[str] = field(
        default=None,
        metadata={
            "name": "annotateWork",
            "type": "Attribute",
        },
    )
    annotate_type: Optional[Union[OsisAnnotation, str]] = field(
        default=None,
        metadata={
            "name": "annotateType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    editions: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "tokens": True,
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    resp: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    n: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lang: Optional[Union[str, LangValue]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    space: Optional[SpaceValue] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    script: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"([A-Z][a-z]{3}|x-[A-Za-z0-9]+)",
        },
    )
    teiform: str = field(
        const=True,
        default="hi",
        metadata={
            "name": "TEIform",
            "type": "Attribute",
        },
    )
    content: list[object] = field(
        default_factory=list,
        metadata={
            "type": "Wildcard",
            "namespace": "##any",
            "mixed": True,
            "choices": (
                {
                    "name": "a",
                    "type": ACt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "abbr",
                    "type": AbbrCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "date",
                    "type": DateCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "divineName",
                    "type": DivineNameCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "foreign",
                    "type": ForeignCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "hi",
                    "type": ForwardRef("HiCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "index",
                    "type": IndexCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "lb",
                    "type": LbCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestone",
                    "type": MilestoneCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestoneEnd",
                    "type": MilestoneEndCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestoneStart",
                    "type": MilestoneStartCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "name",
                    "type": ForwardRef("NameCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "note",
                    "type": ForwardRef("NoteCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "reference",
                    "type": ForwardRef("ReferenceCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "seg",
                    "type": ForwardRef("SegCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "w",
                    "type": ForwardRef("WCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
            ),
        },
    )


class NameCt(BaseModel):
    class Meta:
        name = "nameCT"

    model_config = ConfigDict(defer_build=True)
    canonical: Optional[bool] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    regular: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    type_value: Optional[Union[OsisNames, str]] = field(
        default=None,
        metadata={
            "name": "type",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_work: Optional[str] = field(
        default=None,
        metadata={
            "name": "annotateWork",
            "type": "Attribute",
        },
    )
    annotate_type: Optional[Union[OsisAnnotation, str]] = field(
        default=None,
        metadata={
            "name": "annotateType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    editions: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "tokens": True,
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    resp: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    n: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lang: Optional[Union[str, LangValue]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    space: Optional[SpaceValue] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    script: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"([A-Z][a-z]{3}|x-[A-Za-z0-9]+)",
        },
    )
    teiform: str = field(
        const=True,
        default="name",
        metadata={
            "name": "TEIform",
            "type": "Attribute",
        },
    )
    content: list[object] = field(
        default_factory=list,
        metadata={
            "type": "Wildcard",
            "namespace": "##any",
            "mixed": True,
            "choices": (
                {
                    "name": "a",
                    "type": ACt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "abbr",
                    "type": AbbrCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "foreign",
                    "type": ForeignCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "index",
                    "type": IndexCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "note",
                    "type": ForwardRef("NoteCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "reference",
                    "type": ForwardRef("ReferenceCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "seg",
                    "type": ForwardRef("SegCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "w",
                    "type": ForwardRef("WCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
            ),
        },
    )


class InscriptionCt(BaseModel):
    class Meta:
        name = "inscriptionCT"

    model_config = ConfigDict(defer_build=True)
    canonical: Optional[bool] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_work: Optional[str] = field(
        default=None,
        metadata={
            "name": "annotateWork",
            "type": "Attribute",
        },
    )
    annotate_type: Optional[Union[OsisAnnotation, str]] = field(
        default=None,
        metadata={
            "name": "annotateType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    editions: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "tokens": True,
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    resp: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    type_value: Optional[str] = field(
        default=None,
        metadata={
            "name": "type",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    n: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lang: Optional[Union[str, LangValue]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    space: Optional[SpaceValue] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    script: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"([A-Z][a-z]{3}|x-[A-Za-z0-9]+)",
        },
    )
    content: list[object] = field(
        default_factory=list,
        metadata={
            "type": "Wildcard",
            "namespace": "##any",
            "mixed": True,
            "choices": (
                {
                    "name": "a",
                    "type": ACt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "abbr",
                    "type": AbbrCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "date",
                    "type": DateCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "divineName",
                    "type": DivineNameCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "foreign",
                    "type": ForeignCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "hi",
                    "type": HiCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "index",
                    "type": IndexCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "lb",
                    "type": LbCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestone",
                    "type": MilestoneCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestoneEnd",
                    "type": MilestoneEndCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestoneStart",
                    "type": MilestoneStartCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "name",
                    "type": ForwardRef("NameCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "note",
                    "type": ForwardRef("NoteCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "q",
                    "type": ForwardRef("QCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "reference",
                    "type": ForwardRef("ReferenceCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "seg",
                    "type": ForwardRef("SegCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "speaker",
                    "type": ForwardRef("SpeakerCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "speech",
                    "type": ForwardRef("SpeechCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "title",
                    "type": ForwardRef("TitleCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "w",
                    "type": ForwardRef("WCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
            ),
        },
    )


class ItemCt(BaseModel):
    class Meta:
        name = "itemCT"

    model_config = ConfigDict(defer_build=True)
    canonical: Optional[bool] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    role: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_work: Optional[str] = field(
        default=None,
        metadata={
            "name": "annotateWork",
            "type": "Attribute",
        },
    )
    annotate_type: Optional[Union[OsisAnnotation, str]] = field(
        default=None,
        metadata={
            "name": "annotateType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    editions: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "tokens": True,
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    resp: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    type_value: Optional[str] = field(
        default=None,
        metadata={
            "name": "type",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    n: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lang: Optional[Union[str, LangValue]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    space: Optional[SpaceValue] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    script: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"([A-Z][a-z]{3}|x-[A-Za-z0-9]+)",
        },
    )
    teiform: str = field(
        const=True,
        default="item",
        metadata={
            "name": "TEIform",
            "type": "Attribute",
        },
    )
    content: list[object] = field(
        default_factory=list,
        metadata={
            "type": "Wildcard",
            "namespace": "##any",
            "mixed": True,
            "choices": (
                {
                    "name": "label",
                    "type": ForwardRef("LabelCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "a",
                    "type": ACt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "abbr",
                    "type": AbbrCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "date",
                    "type": DateCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "divineName",
                    "type": DivineNameCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "foreign",
                    "type": ForeignCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "hi",
                    "type": HiCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "index",
                    "type": IndexCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "lg",
                    "type": ForwardRef("LgCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "list",
                    "type": ForwardRef("ListCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "lb",
                    "type": LbCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestone",
                    "type": MilestoneCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestoneEnd",
                    "type": MilestoneEndCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestoneStart",
                    "type": MilestoneStartCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "name",
                    "type": ForwardRef("NameCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "note",
                    "type": ForwardRef("NoteCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "p",
                    "type": ForwardRef("PCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "q",
                    "type": ForwardRef("QCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "reference",
                    "type": ForwardRef("ReferenceCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "seg",
                    "type": ForwardRef("SegCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "title",
                    "type": ForwardRef("TitleCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "transChange",
                    "type": ForwardRef("TransChangeCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "verse",
                    "type": ForwardRef("VerseCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "w",
                    "type": ForwardRef("WCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
            ),
        },
    )


class LCt(Milestoneable):
    class Meta:
        name = "lCT"

    model_config = ConfigDict(defer_build=True)
    canonical: Optional[bool] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    level: Optional[int] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    type_value: Optional[Union[OsisLine, str]] = field(
        default=None,
        metadata={
            "name": "type",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_work: Optional[str] = field(
        default=None,
        metadata={
            "name": "annotateWork",
            "type": "Attribute",
        },
    )
    annotate_type: Optional[Union[OsisAnnotation, str]] = field(
        default=None,
        metadata={
            "name": "annotateType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    editions: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "tokens": True,
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    resp: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    n: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lang: Optional[Union[str, LangValue]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    space: Optional[SpaceValue] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    script: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"([A-Z][a-z]{3}|x-[A-Za-z0-9]+)",
        },
    )
    teiform: str = field(
        const=True,
        default="l",
        metadata={
            "name": "TEIform",
            "type": "Attribute",
        },
    )
    content: list[object] = field(
        default_factory=list,
        metadata={
            "type": "Wildcard",
            "namespace": "##any",
            "mixed": True,
            "choices": (
                {
                    "name": "a",
                    "type": ACt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "abbr",
                    "type": AbbrCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "chapter",
                    "type": ChapterCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "date",
                    "type": DateCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "divineName",
                    "type": DivineNameCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "foreign",
                    "type": ForeignCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "hi",
                    "type": HiCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "index",
                    "type": IndexCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "lb",
                    "type": LbCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "mentioned",
                    "type": ForwardRef("MentionedCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestone",
                    "type": MilestoneCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestoneEnd",
                    "type": MilestoneEndCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestoneStart",
                    "type": MilestoneStartCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "name",
                    "type": ForwardRef("NameCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "note",
                    "type": ForwardRef("NoteCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "q",
                    "type": ForwardRef("QCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "reference",
                    "type": ForwardRef("ReferenceCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "seg",
                    "type": ForwardRef("SegCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "speaker",
                    "type": ForwardRef("SpeakerCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "transChange",
                    "type": ForwardRef("TransChangeCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "verse",
                    "type": ForwardRef("VerseCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "w",
                    "type": ForwardRef("WCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
            ),
        },
    )


class MentionedCt(BaseModel):
    class Meta:
        name = "mentionedCT"

    model_config = ConfigDict(defer_build=True)
    canonical: Optional[bool] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_work: Optional[str] = field(
        default=None,
        metadata={
            "name": "annotateWork",
            "type": "Attribute",
        },
    )
    annotate_type: Optional[Union[OsisAnnotation, str]] = field(
        default=None,
        metadata={
            "name": "annotateType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    editions: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "tokens": True,
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    resp: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    type_value: Optional[str] = field(
        default=None,
        metadata={
            "name": "type",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    n: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lang: Optional[Union[str, LangValue]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    space: Optional[SpaceValue] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    script: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"([A-Z][a-z]{3}|x-[A-Za-z0-9]+)",
        },
    )
    teiform: str = field(
        const=True,
        default="mentioned",
        metadata={
            "name": "TEIform",
            "type": "Attribute",
        },
    )
    content: list[object] = field(
        default_factory=list,
        metadata={
            "type": "Wildcard",
            "namespace": "##any",
            "mixed": True,
            "choices": (
                {
                    "name": "a",
                    "type": ACt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "abbr",
                    "type": AbbrCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "date",
                    "type": DateCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "divineName",
                    "type": DivineNameCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "foreign",
                    "type": ForeignCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "hi",
                    "type": HiCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "index",
                    "type": IndexCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "lb",
                    "type": LbCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestone",
                    "type": MilestoneCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestoneEnd",
                    "type": MilestoneEndCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestoneStart",
                    "type": MilestoneStartCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "name",
                    "type": ForwardRef("NameCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "note",
                    "type": ForwardRef("NoteCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "q",
                    "type": ForwardRef("QCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "reference",
                    "type": ForwardRef("ReferenceCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "seg",
                    "type": ForwardRef("SegCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "transChange",
                    "type": ForwardRef("TransChangeCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "w",
                    "type": ForwardRef("WCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
            ),
        },
    )


class TableCt(BaseModel):
    class Meta:
        name = "tableCT"

    model_config = ConfigDict(defer_build=True)
    head: Optional[HeadCt] = field(
        default=None,
        metadata={
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
        },
    )
    row: list[RowCt] = field(
        default_factory=list,
        metadata={
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
        },
    )
    canonical: Optional[bool] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    cols: Optional[int] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    rows: Optional[int] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_work: Optional[str] = field(
        default=None,
        metadata={
            "name": "annotateWork",
            "type": "Attribute",
        },
    )
    annotate_type: Optional[Union[OsisAnnotation, str]] = field(
        default=None,
        metadata={
            "name": "annotateType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    editions: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "tokens": True,
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    resp: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    type_value: Optional[str] = field(
        default=None,
        metadata={
            "name": "type",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    n: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lang: Optional[Union[str, LangValue]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    space: Optional[SpaceValue] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    script: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"([A-Z][a-z]{3}|x-[A-Za-z0-9]+)",
        },
    )
    teiform: str = field(
        const=True,
        default="table",
        metadata={
            "name": "TEIform",
            "type": "Attribute",
        },
    )


class LgCt(Milestoneable):
    class Meta:
        name = "lgCT"

    model_config = ConfigDict(defer_build=True)
    chapter: list[ChapterCt] = field(
        default_factory=list,
        metadata={
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
        },
    )
    index: list[IndexCt] = field(
        default_factory=list,
        metadata={
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
        },
    )
    l: list[LCt] = field(
        default_factory=list,
        metadata={
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
        },
    )
    lb: list[LbCt] = field(
        default_factory=list,
        metadata={
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
        },
    )
    lg: list["LgCt"] = field(
        default_factory=list,
        metadata={
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
        },
    )
    milestone: list[MilestoneCt] = field(
        default_factory=list,
        metadata={
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
        },
    )
    milestone_end: list[MilestoneEndCt] = field(
        default_factory=list,
        metadata={
            "name": "milestoneEnd",
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
        },
    )
    milestone_start: list[MilestoneStartCt] = field(
        default_factory=list,
        metadata={
            "name": "milestoneStart",
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
        },
    )
    q: list["QCt"] = field(
        default_factory=list,
        metadata={
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
        },
    )
    verse: list["VerseCt"] = field(
        default_factory=list,
        metadata={
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
        },
    )
    canonical: Optional[bool] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    type_value: Optional[str] = field(
        default=None,
        metadata={
            "name": "type",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_work: Optional[str] = field(
        default=None,
        metadata={
            "name": "annotateWork",
            "type": "Attribute",
        },
    )
    annotate_type: Optional[Union[OsisAnnotation, str]] = field(
        default=None,
        metadata={
            "name": "annotateType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    editions: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "tokens": True,
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    resp: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    n: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lang: Optional[Union[str, LangValue]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    space: Optional[SpaceValue] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    script: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"([A-Z][a-z]{3}|x-[A-Za-z0-9]+)",
        },
    )
    teiform: str = field(
        const=True,
        default="lg",
        metadata={
            "name": "TEIform",
            "type": "Attribute",
        },
    )


class ListCt(BaseModel):
    class Meta:
        name = "listCT"

    model_config = ConfigDict(defer_build=True)
    canonical: Optional[bool] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_work: Optional[str] = field(
        default=None,
        metadata={
            "name": "annotateWork",
            "type": "Attribute",
        },
    )
    annotate_type: Optional[Union[OsisAnnotation, str]] = field(
        default=None,
        metadata={
            "name": "annotateType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    editions: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "tokens": True,
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    resp: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    type_value: Optional[str] = field(
        default=None,
        metadata={
            "name": "type",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    n: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lang: Optional[Union[str, LangValue]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    space: Optional[SpaceValue] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    script: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"([A-Z][a-z]{3}|x-[A-Za-z0-9]+)",
        },
    )
    teiform: str = field(
        const=True,
        default="list",
        metadata={
            "name": "TEIform",
            "type": "Attribute",
        },
    )
    content: list[object] = field(
        default_factory=list,
        metadata={
            "type": "Wildcard",
            "namespace": "##any",
            "mixed": True,
            "choices": (
                {
                    "name": "chapter",
                    "type": ChapterCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "head",
                    "type": HeadCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "index",
                    "type": IndexCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "item",
                    "type": ItemCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "lb",
                    "type": LbCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestone",
                    "type": MilestoneCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestoneEnd",
                    "type": MilestoneEndCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestoneStart",
                    "type": MilestoneStartCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "q",
                    "type": ForwardRef("QCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "verse",
                    "type": ForwardRef("VerseCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
            ),
        },
    )


class NoteCt(BaseModel):
    class Meta:
        name = "noteCT"

    model_config = ConfigDict(defer_build=True)
    canonical: bool = field(
        default=False,
        metadata={
            "type": "Attribute",
        },
    )
    osis_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    placement: Optional[Union[OsisPlacementNote, str]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    type_value: Optional[Union[OsisNotes, str]] = field(
        default=None,
        metadata={
            "name": "type",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_work: Optional[str] = field(
        default=None,
        metadata={
            "name": "annotateWork",
            "type": "Attribute",
        },
    )
    annotate_type: Optional[Union[OsisAnnotation, str]] = field(
        default=None,
        metadata={
            "name": "annotateType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    editions: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "tokens": True,
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    resp: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    n: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lang: Optional[Union[str, LangValue]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    space: Optional[SpaceValue] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    script: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"([A-Z][a-z]{3}|x-[A-Za-z0-9]+)",
        },
    )
    teiform: str = field(
        const=True,
        default="note",
        metadata={
            "name": "TEIform",
            "type": "Attribute",
        },
    )
    content: list[object] = field(
        default_factory=list,
        metadata={
            "type": "Wildcard",
            "namespace": "##any",
            "mixed": True,
            "choices": (
                {
                    "name": "note",
                    "type": ForwardRef("NoteCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "a",
                    "type": ACt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "abbr",
                    "type": AbbrCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "catchWord",
                    "type": CatchWordCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "date",
                    "type": DateCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "divineName",
                    "type": DivineNameCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "figure",
                    "type": FigureCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "foreign",
                    "type": ForeignCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "hi",
                    "type": HiCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "index",
                    "type": IndexCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "inscription",
                    "type": InscriptionCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "lb",
                    "type": LbCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "lg",
                    "type": LgCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "list",
                    "type": ListCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "mentioned",
                    "type": MentionedCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestone",
                    "type": MilestoneCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestoneEnd",
                    "type": MilestoneEndCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestoneStart",
                    "type": MilestoneStartCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "name",
                    "type": NameCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "p",
                    "type": ForwardRef("PCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "q",
                    "type": ForwardRef("QCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "rdg",
                    "type": ForwardRef("RdgCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "rdgGrp",
                    "type": ForwardRef("RdgGrpCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "reference",
                    "type": ForwardRef("ReferenceCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "seg",
                    "type": ForwardRef("SegCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "table",
                    "type": TableCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "title",
                    "type": ForwardRef("TitleCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "verse",
                    "type": ForwardRef("VerseCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "w",
                    "type": ForwardRef("WCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
            ),
        },
    )


class PCt(BaseModel):
    class Meta:
        name = "pCT"

    model_config = ConfigDict(defer_build=True)
    canonical: Optional[bool] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_work: Optional[str] = field(
        default=None,
        metadata={
            "name": "annotateWork",
            "type": "Attribute",
        },
    )
    annotate_type: Optional[Union[OsisAnnotation, str]] = field(
        default=None,
        metadata={
            "name": "annotateType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    editions: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "tokens": True,
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    resp: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    type_value: Optional[str] = field(
        default=None,
        metadata={
            "name": "type",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    n: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lang: Optional[Union[str, LangValue]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    space: Optional[SpaceValue] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    script: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"([A-Z][a-z]{3}|x-[A-Za-z0-9]+)",
        },
    )
    teiform: str = field(
        const=True,
        default="p",
        metadata={
            "name": "TEIform",
            "type": "Attribute",
        },
    )
    content: list[object] = field(
        default_factory=list,
        metadata={
            "type": "Wildcard",
            "namespace": "##any",
            "mixed": True,
            "choices": (
                {
                    "name": "a",
                    "type": ACt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "abbr",
                    "type": AbbrCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "catchWord",
                    "type": CatchWordCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "chapter",
                    "type": ChapterCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "closer",
                    "type": CloserCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "date",
                    "type": DateCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "divineName",
                    "type": DivineNameCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "figure",
                    "type": FigureCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "foreign",
                    "type": ForeignCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "hi",
                    "type": HiCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "index",
                    "type": IndexCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "inscription",
                    "type": InscriptionCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "lb",
                    "type": LbCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "lg",
                    "type": LgCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "list",
                    "type": ListCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "mentioned",
                    "type": MentionedCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestone",
                    "type": MilestoneCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestoneEnd",
                    "type": MilestoneEndCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestoneStart",
                    "type": MilestoneStartCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "name",
                    "type": NameCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "note",
                    "type": NoteCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "q",
                    "type": ForwardRef("QCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "rdg",
                    "type": ForwardRef("RdgCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "rdgGrp",
                    "type": ForwardRef("RdgGrpCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "reference",
                    "type": ForwardRef("ReferenceCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "salute",
                    "type": ForwardRef("SaluteCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "seg",
                    "type": ForwardRef("SegCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "signed",
                    "type": ForwardRef("SignedCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "speaker",
                    "type": ForwardRef("SpeakerCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "speech",
                    "type": ForwardRef("SpeechCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "table",
                    "type": TableCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "title",
                    "type": ForwardRef("TitleCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "transChange",
                    "type": ForwardRef("TransChangeCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "verse",
                    "type": ForwardRef("VerseCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "w",
                    "type": ForwardRef("WCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
            ),
        },
    )


class ReferenceCt(BaseModel):
    class Meta:
        name = "referenceCT"

    model_config = ConfigDict(defer_build=True)
    canonical: bool = field(
        default=False,
        metadata={
            "type": "Attribute",
        },
    )
    osis_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    type_value: Optional[Union[OsisReferences, str]] = field(
        default=None,
        metadata={
            "name": "type",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_work: Optional[str] = field(
        default=None,
        metadata={
            "name": "annotateWork",
            "type": "Attribute",
        },
    )
    annotate_type: Optional[Union[OsisAnnotation, str]] = field(
        default=None,
        metadata={
            "name": "annotateType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    editions: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "tokens": True,
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    resp: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    n: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lang: Optional[Union[str, LangValue]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    space: Optional[SpaceValue] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    script: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"([A-Z][a-z]{3}|x-[A-Za-z0-9]+)",
        },
    )
    content: list[object] = field(
        default_factory=list,
        metadata={
            "type": "Wildcard",
            "namespace": "##any",
            "mixed": True,
            "choices": (
                {
                    "name": "a",
                    "type": ACt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "abbr",
                    "type": AbbrCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "date",
                    "type": DateCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "divineName",
                    "type": DivineNameCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "foreign",
                    "type": ForeignCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "hi",
                    "type": HiCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "index",
                    "type": IndexCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "lb",
                    "type": LbCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestone",
                    "type": MilestoneCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestoneEnd",
                    "type": MilestoneEndCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestoneStart",
                    "type": MilestoneStartCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "name",
                    "type": NameCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "note",
                    "type": NoteCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "seg",
                    "type": ForwardRef("SegCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "title",
                    "type": ForwardRef("TitleCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "w",
                    "type": ForwardRef("WCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
            ),
        },
    )


class QCt(Milestoneable):
    class Meta:
        name = "qCT"

    model_config = ConfigDict(defer_build=True)
    canonical: Optional[bool] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    level: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    marker: str = field(
        default="DEFAULT",
        metadata={
            "type": "Attribute",
        },
    )
    osis_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    type_value: Optional[Union[OsisQuotes, str]] = field(
        default=None,
        metadata={
            "name": "type",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    who: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_work: Optional[str] = field(
        default=None,
        metadata={
            "name": "annotateWork",
            "type": "Attribute",
        },
    )
    annotate_type: Optional[Union[OsisAnnotation, str]] = field(
        default=None,
        metadata={
            "name": "annotateType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    editions: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "tokens": True,
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    resp: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    n: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lang: Optional[Union[str, LangValue]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    space: Optional[SpaceValue] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    script: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"([A-Z][a-z]{3}|x-[A-Za-z0-9]+)",
        },
    )
    teiform: str = field(
        const=True,
        default="q",
        metadata={
            "name": "TEIform",
            "type": "Attribute",
        },
    )
    content: list[object] = field(
        default_factory=list,
        metadata={
            "type": "Wildcard",
            "namespace": "##any",
            "mixed": True,
            "choices": (
                {
                    "name": "a",
                    "type": ACt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "abbr",
                    "type": AbbrCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "closer",
                    "type": CloserCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "date",
                    "type": DateCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "divineName",
                    "type": DivineNameCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "foreign",
                    "type": ForeignCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "hi",
                    "type": HiCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "index",
                    "type": IndexCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "inscription",
                    "type": InscriptionCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "lb",
                    "type": LbCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "lg",
                    "type": LgCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "list",
                    "type": ListCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "mentioned",
                    "type": MentionedCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestone",
                    "type": MilestoneCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestoneEnd",
                    "type": MilestoneEndCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestoneStart",
                    "type": MilestoneStartCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "name",
                    "type": NameCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "note",
                    "type": NoteCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "p",
                    "type": PCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "q",
                    "type": ForwardRef("QCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "reference",
                    "type": ForwardRef("ReferenceCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "salute",
                    "type": ForwardRef("SaluteCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "seg",
                    "type": ForwardRef("SegCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "signed",
                    "type": ForwardRef("SignedCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "speaker",
                    "type": ForwardRef("SpeakerCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "transChange",
                    "type": ForwardRef("TransChangeCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "verse",
                    "type": ForwardRef("VerseCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "w",
                    "type": ForwardRef("WCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
            ),
        },
    )


class RevisionDescCt(BaseModel):
    class Meta:
        name = "revisionDescCT"

    model_config = ConfigDict(defer_build=True)
    date: DateCt = field(
        metadata={
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
            "required": True,
        }
    )
    p: list[PCt] = field(
        default_factory=list,
        metadata={
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
            "min_occurs": 1,
        },
    )
    canonical: Optional[bool] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_work: Optional[str] = field(
        default=None,
        metadata={
            "name": "annotateWork",
            "type": "Attribute",
        },
    )
    annotate_type: Optional[Union[OsisAnnotation, str]] = field(
        default=None,
        metadata={
            "name": "annotateType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    editions: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "tokens": True,
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    resp: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    type_value: Optional[str] = field(
        default=None,
        metadata={
            "name": "type",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    n: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lang: Optional[Union[str, LangValue]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    space: Optional[SpaceValue] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    script: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"([A-Z][a-z]{3}|x-[A-Za-z0-9]+)",
        },
    )
    teiform: str = field(
        const=True,
        default="revisionDesc",
        metadata={
            "name": "TEIform",
            "type": "Attribute",
        },
    )


class SegCt(Milestoneable):
    class Meta:
        name = "segCT"

    model_config = ConfigDict(defer_build=True)
    canonical: Optional[bool] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    type_value: Optional[Union[OsisSegs, str]] = field(
        default=None,
        metadata={
            "name": "type",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_work: Optional[str] = field(
        default=None,
        metadata={
            "name": "annotateWork",
            "type": "Attribute",
        },
    )
    annotate_type: Optional[Union[OsisAnnotation, str]] = field(
        default=None,
        metadata={
            "name": "annotateType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    editions: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "tokens": True,
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    resp: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    n: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lang: Optional[Union[str, LangValue]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    space: Optional[SpaceValue] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    script: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"([A-Z][a-z]{3}|x-[A-Za-z0-9]+)",
        },
    )
    teiform: str = field(
        const=True,
        default="seg",
        metadata={
            "name": "TEIform",
            "type": "Attribute",
        },
    )
    content: list[object] = field(
        default_factory=list,
        metadata={
            "type": "Wildcard",
            "namespace": "##any",
            "mixed": True,
            "choices": (
                {
                    "name": "a",
                    "type": ACt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "abbr",
                    "type": AbbrCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "date",
                    "type": DateCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "divineName",
                    "type": DivineNameCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "foreign",
                    "type": ForeignCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "hi",
                    "type": HiCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "index",
                    "type": IndexCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "lb",
                    "type": LbCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestone",
                    "type": MilestoneCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestoneEnd",
                    "type": MilestoneEndCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestoneStart",
                    "type": MilestoneStartCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "name",
                    "type": NameCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "note",
                    "type": NoteCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "q",
                    "type": QCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "reference",
                    "type": ReferenceCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "seg",
                    "type": ForwardRef("SegCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "transChange",
                    "type": ForwardRef("TransChangeCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "w",
                    "type": ForwardRef("WCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
            ),
        },
    )


class WCt(BaseModel):
    class Meta:
        name = "wCT"

    model_config = ConfigDict(defer_build=True)
    canonical: Optional[bool] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    gloss: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lemma: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "pattern": r"((((\p{L}|\p{N}|_)+)(\.(\p{L}|\p{N}|_))*:)?([^:\s])+)",
            "tokens": True,
        },
    )
    morph: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "pattern": r"((((\p{L}|\p{N}|_)+)(\.(\p{L}|\p{N}|_))*:)?([^:\s])+)",
            "tokens": True,
        },
    )
    pos: list[str] = field(
        default_factory=list,
        metadata={
            "name": "POS",
            "type": "Attribute",
            "pattern": r"((((\p{L}|\p{N}|_)+)(\.(\p{L}|\p{N}|_))*:)?([^:\s])+)",
            "tokens": True,
        },
    )
    src: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    xlit: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_work: Optional[str] = field(
        default=None,
        metadata={
            "name": "annotateWork",
            "type": "Attribute",
        },
    )
    annotate_type: Optional[Union[OsisAnnotation, str]] = field(
        default=None,
        metadata={
            "name": "annotateType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    editions: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "tokens": True,
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    resp: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    type_value: Optional[str] = field(
        default=None,
        metadata={
            "name": "type",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    n: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lang: Optional[Union[str, LangValue]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    space: Optional[SpaceValue] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    script: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"([A-Z][a-z]{3}|x-[A-Za-z0-9]+)",
        },
    )
    teiform: str = field(
        const=True,
        default="w",
        metadata={
            "name": "TEIform",
            "type": "Attribute",
        },
    )
    content: list[object] = field(
        default_factory=list,
        metadata={
            "type": "Wildcard",
            "namespace": "##any",
            "mixed": True,
            "choices": (
                {
                    "name": "a",
                    "type": ACt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "index",
                    "type": IndexCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "note",
                    "type": NoteCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "seg",
                    "type": SegCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
            ),
        },
    )


class ActorCt(BaseModel):
    class Meta:
        name = "actorCT"

    model_config = ConfigDict(defer_build=True)
    canonical: Optional[bool] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    who: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_work: Optional[str] = field(
        default=None,
        metadata={
            "name": "annotateWork",
            "type": "Attribute",
        },
    )
    annotate_type: Optional[Union[OsisAnnotation, str]] = field(
        default=None,
        metadata={
            "name": "annotateType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    editions: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "tokens": True,
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    resp: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    type_value: Optional[str] = field(
        default=None,
        metadata={
            "name": "type",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    n: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lang: Optional[Union[str, LangValue]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    space: Optional[SpaceValue] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    script: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"([A-Z][a-z]{3}|x-[A-Za-z0-9]+)",
        },
    )
    teiform: str = field(
        const=True,
        default="actor",
        metadata={
            "name": "TEIform",
            "type": "Attribute",
        },
    )
    content: list[object] = field(
        default_factory=list,
        metadata={
            "type": "Wildcard",
            "namespace": "##any",
            "mixed": True,
            "choices": (
                {
                    "name": "a",
                    "type": ACt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "abbr",
                    "type": AbbrCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "foreign",
                    "type": ForeignCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "index",
                    "type": IndexCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "note",
                    "type": NoteCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "reference",
                    "type": ReferenceCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "seg",
                    "type": SegCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "w",
                    "type": WCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
            ),
        },
    )


class RoleCt(BaseModel):
    class Meta:
        name = "roleCT"

    model_config = ConfigDict(defer_build=True)
    canonical: Optional[bool] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_work: Optional[str] = field(
        default=None,
        metadata={
            "name": "annotateWork",
            "type": "Attribute",
        },
    )
    annotate_type: Optional[Union[OsisAnnotation, str]] = field(
        default=None,
        metadata={
            "name": "annotateType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    editions: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "tokens": True,
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    resp: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    type_value: Optional[str] = field(
        default=None,
        metadata={
            "name": "type",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    n: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lang: Optional[Union[str, LangValue]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    space: Optional[SpaceValue] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    script: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"([A-Z][a-z]{3}|x-[A-Za-z0-9]+)",
        },
    )
    teiform: str = field(
        const=True,
        default="role",
        metadata={
            "name": "TEIform",
            "type": "Attribute",
        },
    )
    content: list[object] = field(
        default_factory=list,
        metadata={
            "type": "Wildcard",
            "namespace": "##any",
            "mixed": True,
            "choices": (
                {
                    "name": "a",
                    "type": ACt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "abbr",
                    "type": AbbrCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "foreign",
                    "type": ForeignCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "index",
                    "type": IndexCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "note",
                    "type": NoteCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "reference",
                    "type": ReferenceCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "seg",
                    "type": SegCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "w",
                    "type": WCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
            ),
        },
    )


class RoleDescCt(BaseModel):
    class Meta:
        name = "roleDescCT"

    model_config = ConfigDict(defer_build=True)
    canonical: Optional[bool] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_work: Optional[str] = field(
        default=None,
        metadata={
            "name": "annotateWork",
            "type": "Attribute",
        },
    )
    annotate_type: Optional[Union[OsisAnnotation, str]] = field(
        default=None,
        metadata={
            "name": "annotateType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    editions: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "tokens": True,
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    resp: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    type_value: Optional[str] = field(
        default=None,
        metadata={
            "name": "type",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    n: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lang: Optional[Union[str, LangValue]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    space: Optional[SpaceValue] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    script: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"([A-Z][a-z]{3}|x-[A-Za-z0-9]+)",
        },
    )
    teiform: str = field(
        const=True,
        default="roleDesc",
        metadata={
            "name": "TEIform",
            "type": "Attribute",
        },
    )
    content: list[object] = field(
        default_factory=list,
        metadata={
            "type": "Wildcard",
            "namespace": "##any",
            "mixed": True,
            "choices": (
                {
                    "name": "a",
                    "type": ACt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "abbr",
                    "type": AbbrCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "foreign",
                    "type": ForeignCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "index",
                    "type": IndexCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "note",
                    "type": NoteCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "reference",
                    "type": ReferenceCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "seg",
                    "type": SegCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "w",
                    "type": WCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
            ),
        },
    )


class SignedCt(Milestoneable):
    class Meta:
        name = "signedCT"

    model_config = ConfigDict(defer_build=True)
    canonical: Optional[bool] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_work: Optional[str] = field(
        default=None,
        metadata={
            "name": "annotateWork",
            "type": "Attribute",
        },
    )
    annotate_type: Optional[Union[OsisAnnotation, str]] = field(
        default=None,
        metadata={
            "name": "annotateType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    editions: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "tokens": True,
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    resp: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    type_value: Optional[str] = field(
        default=None,
        metadata={
            "name": "type",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    n: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lang: Optional[Union[str, LangValue]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    space: Optional[SpaceValue] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    script: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"([A-Z][a-z]{3}|x-[A-Za-z0-9]+)",
        },
    )
    teiform: str = field(
        const=True,
        default="signed",
        metadata={
            "name": "TEIform",
            "type": "Attribute",
        },
    )
    content: list[object] = field(
        default_factory=list,
        metadata={
            "type": "Wildcard",
            "namespace": "##any",
            "mixed": True,
            "choices": (
                {
                    "name": "a",
                    "type": ACt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "abbr",
                    "type": AbbrCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "divineName",
                    "type": DivineNameCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "foreign",
                    "type": ForeignCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "hi",
                    "type": HiCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "index",
                    "type": IndexCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "lb",
                    "type": LbCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestone",
                    "type": MilestoneCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestoneEnd",
                    "type": MilestoneEndCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestoneStart",
                    "type": MilestoneStartCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "name",
                    "type": NameCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "note",
                    "type": NoteCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "reference",
                    "type": ReferenceCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "seg",
                    "type": SegCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "w",
                    "type": WCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
            ),
        },
    )


class SpeakerCt(BaseModel):
    class Meta:
        name = "speakerCT"

    model_config = ConfigDict(defer_build=True)
    canonical: Optional[bool] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    who: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_work: Optional[str] = field(
        default=None,
        metadata={
            "name": "annotateWork",
            "type": "Attribute",
        },
    )
    annotate_type: Optional[Union[OsisAnnotation, str]] = field(
        default=None,
        metadata={
            "name": "annotateType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    editions: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "tokens": True,
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    resp: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    type_value: Optional[str] = field(
        default=None,
        metadata={
            "name": "type",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    n: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lang: Optional[Union[str, LangValue]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    space: Optional[SpaceValue] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    script: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"([A-Z][a-z]{3}|x-[A-Za-z0-9]+)",
        },
    )
    teiform: str = field(
        const=True,
        default="sp",
        metadata={
            "name": "TEIform",
            "type": "Attribute",
        },
    )
    content: list[object] = field(
        default_factory=list,
        metadata={
            "type": "Wildcard",
            "namespace": "##any",
            "mixed": True,
            "choices": (
                {
                    "name": "a",
                    "type": ACt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "abbr",
                    "type": AbbrCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "divineName",
                    "type": DivineNameCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "foreign",
                    "type": ForeignCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "index",
                    "type": IndexCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "name",
                    "type": NameCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "note",
                    "type": NoteCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "reference",
                    "type": ReferenceCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "w",
                    "type": WCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
            ),
        },
    )


class TransChangeCt(BaseModel):
    class Meta:
        name = "transChangeCT"

    model_config = ConfigDict(defer_build=True)
    canonical: Optional[bool] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    type_value: Optional[Union[OsisChanges, str]] = field(
        default=None,
        metadata={
            "name": "type",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_work: Optional[str] = field(
        default=None,
        metadata={
            "name": "annotateWork",
            "type": "Attribute",
        },
    )
    annotate_type: Optional[Union[OsisAnnotation, str]] = field(
        default=None,
        metadata={
            "name": "annotateType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    editions: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "tokens": True,
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    resp: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    n: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lang: Optional[Union[str, LangValue]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    space: Optional[SpaceValue] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    script: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"([A-Z][a-z]{3}|x-[A-Za-z0-9]+)",
        },
    )
    content: list[object] = field(
        default_factory=list,
        metadata={
            "type": "Wildcard",
            "namespace": "##any",
            "mixed": True,
            "choices": (
                {
                    "name": "a",
                    "type": ACt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "abbr",
                    "type": AbbrCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "date",
                    "type": DateCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "divineName",
                    "type": DivineNameCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "foreign",
                    "type": ForeignCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "hi",
                    "type": HiCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "index",
                    "type": IndexCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "lb",
                    "type": LbCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestone",
                    "type": MilestoneCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestoneEnd",
                    "type": MilestoneEndCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestoneStart",
                    "type": MilestoneStartCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "name",
                    "type": NameCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "note",
                    "type": NoteCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "q",
                    "type": QCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "reference",
                    "type": ReferenceCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "seg",
                    "type": SegCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "w",
                    "type": WCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
            ),
        },
    )


class CastItemCt(BaseModel):
    class Meta:
        name = "castItemCT"

    model_config = ConfigDict(defer_build=True)
    actor: list[ActorCt] = field(
        default_factory=list,
        metadata={
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
        },
    )
    role: list[RoleCt] = field(
        default_factory=list,
        metadata={
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
        },
    )
    role_desc: list[RoleDescCt] = field(
        default_factory=list,
        metadata={
            "name": "roleDesc",
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
        },
    )
    canonical: Optional[bool] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_work: Optional[str] = field(
        default=None,
        metadata={
            "name": "annotateWork",
            "type": "Attribute",
        },
    )
    annotate_type: Optional[Union[OsisAnnotation, str]] = field(
        default=None,
        metadata={
            "name": "annotateType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    editions: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "tokens": True,
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    resp: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    type_value: Optional[str] = field(
        default=None,
        metadata={
            "name": "type",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    n: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lang: Optional[Union[str, LangValue]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    space: Optional[SpaceValue] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    script: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"([A-Z][a-z]{3}|x-[A-Za-z0-9]+)",
        },
    )
    teiform: str = field(
        const=True,
        default="castItem",
        metadata={
            "name": "TEIform",
            "type": "Attribute",
        },
    )


class LabelCt(BaseModel):
    class Meta:
        name = "labelCT"

    model_config = ConfigDict(defer_build=True)
    canonical: Optional[bool] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    role: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_work: Optional[str] = field(
        default=None,
        metadata={
            "name": "annotateWork",
            "type": "Attribute",
        },
    )
    annotate_type: Optional[Union[OsisAnnotation, str]] = field(
        default=None,
        metadata={
            "name": "annotateType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    editions: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "tokens": True,
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    resp: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    type_value: Optional[str] = field(
        default=None,
        metadata={
            "name": "type",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    n: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lang: Optional[Union[str, LangValue]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    space: Optional[SpaceValue] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    script: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"([A-Z][a-z]{3}|x-[A-Za-z0-9]+)",
        },
    )
    teiform: str = field(
        const=True,
        default="label",
        metadata={
            "name": "TEIform",
            "type": "Attribute",
        },
    )
    content: list[object] = field(
        default_factory=list,
        metadata={
            "type": "Wildcard",
            "namespace": "##any",
            "mixed": True,
            "choices": (
                {
                    "name": "a",
                    "type": ACt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "abbr",
                    "type": AbbrCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "date",
                    "type": DateCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "divineName",
                    "type": DivineNameCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "foreign",
                    "type": ForeignCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "hi",
                    "type": HiCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "index",
                    "type": IndexCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "lb",
                    "type": LbCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestone",
                    "type": MilestoneCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestoneEnd",
                    "type": MilestoneEndCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestoneStart",
                    "type": MilestoneStartCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "name",
                    "type": NameCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "note",
                    "type": NoteCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "q",
                    "type": QCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "reference",
                    "type": ReferenceCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "seg",
                    "type": SegCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "transChange",
                    "type": TransChangeCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "w",
                    "type": WCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
            ),
        },
    )


class RdgCt(BaseModel):
    class Meta:
        name = "rdgCT"

    model_config = ConfigDict(defer_build=True)
    canonical: Optional[bool] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    witness: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    type_value: Optional[Union[OsisRdg, str]] = field(
        default=None,
        metadata={
            "name": "type",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_work: Optional[str] = field(
        default=None,
        metadata={
            "name": "annotateWork",
            "type": "Attribute",
        },
    )
    annotate_type: Optional[Union[OsisAnnotation, str]] = field(
        default=None,
        metadata={
            "name": "annotateType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    editions: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "tokens": True,
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    resp: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    n: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lang: Optional[Union[str, LangValue]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    space: Optional[SpaceValue] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    script: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"([A-Z][a-z]{3}|x-[A-Za-z0-9]+)",
        },
    )
    teiform: str = field(
        const=True,
        default="rdg",
        metadata={
            "name": "TEIform",
            "type": "Attribute",
        },
    )
    content: list[object] = field(
        default_factory=list,
        metadata={
            "type": "Wildcard",
            "namespace": "##any",
            "mixed": True,
            "choices": (
                {
                    "name": "a",
                    "type": ACt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "abbr",
                    "type": AbbrCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "date",
                    "type": DateCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "divineName",
                    "type": DivineNameCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "foreign",
                    "type": ForeignCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "hi",
                    "type": HiCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "index",
                    "type": IndexCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "lb",
                    "type": LbCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "lg",
                    "type": LgCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "list",
                    "type": ListCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestone",
                    "type": MilestoneCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestoneEnd",
                    "type": MilestoneEndCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestoneStart",
                    "type": MilestoneStartCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "name",
                    "type": NameCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "note",
                    "type": NoteCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "p",
                    "type": PCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "q",
                    "type": QCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "reference",
                    "type": ReferenceCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "seg",
                    "type": SegCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "transChange",
                    "type": TransChangeCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "w",
                    "type": WCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
            ),
        },
    )


class TitleCt(BaseModel):
    class Meta:
        name = "titleCT"

    model_config = ConfigDict(defer_build=True)
    canonical: bool = field(
        default=False,
        metadata={
            "type": "Attribute",
        },
    )
    level: Optional[int] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    placement: Optional[Union[OsisPlacementTitle, str]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    short: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    type_value: Optional[Union[OsisTitles, str]] = field(
        default=None,
        metadata={
            "name": "type",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_work: Optional[str] = field(
        default=None,
        metadata={
            "name": "annotateWork",
            "type": "Attribute",
        },
    )
    annotate_type: Optional[Union[OsisAnnotation, str]] = field(
        default=None,
        metadata={
            "name": "annotateType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    editions: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "tokens": True,
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    resp: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    n: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lang: Optional[Union[str, LangValue]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    space: Optional[SpaceValue] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    script: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"([A-Z][a-z]{3}|x-[A-Za-z0-9]+)",
        },
    )
    teiform: str = field(
        const=True,
        default="title",
        metadata={
            "name": "TEIform",
            "type": "Attribute",
        },
    )
    content: list[object] = field(
        default_factory=list,
        metadata={
            "type": "Wildcard",
            "namespace": "##any",
            "mixed": True,
            "choices": (
                {
                    "name": "a",
                    "type": ACt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "abbr",
                    "type": AbbrCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "date",
                    "type": DateCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "divineName",
                    "type": DivineNameCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "figure",
                    "type": FigureCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "foreign",
                    "type": ForeignCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "hi",
                    "type": HiCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "index",
                    "type": IndexCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "inscription",
                    "type": InscriptionCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "lb",
                    "type": LbCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "lg",
                    "type": LgCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestone",
                    "type": MilestoneCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "name",
                    "type": NameCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "note",
                    "type": NoteCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "q",
                    "type": QCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "reference",
                    "type": ReferenceCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "seg",
                    "type": SegCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "title",
                    "type": ForwardRef("TitleCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "transChange",
                    "type": TransChangeCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "verse",
                    "type": ForwardRef("VerseCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "w",
                    "type": WCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
            ),
        },
    )


class CastGroupCt(BaseModel):
    class Meta:
        name = "castGroupCT"

    model_config = ConfigDict(defer_build=True)
    head: list[HeadCt] = field(
        default_factory=list,
        metadata={
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
        },
    )
    cast_item: list[CastItemCt] = field(
        default_factory=list,
        metadata={
            "name": "castItem",
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
        },
    )
    canonical: Optional[bool] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_work: Optional[str] = field(
        default=None,
        metadata={
            "name": "annotateWork",
            "type": "Attribute",
        },
    )
    annotate_type: Optional[Union[OsisAnnotation, str]] = field(
        default=None,
        metadata={
            "name": "annotateType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    editions: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "tokens": True,
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    resp: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    type_value: Optional[str] = field(
        default=None,
        metadata={
            "name": "type",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    n: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lang: Optional[Union[str, LangValue]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    space: Optional[SpaceValue] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    script: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"([A-Z][a-z]{3}|x-[A-Za-z0-9]+)",
        },
    )
    teiform: str = field(
        const=True,
        default="castGroup",
        metadata={
            "name": "TEIform",
            "type": "Attribute",
        },
    )


class RdgGrpCt(BaseModel):
    class Meta:
        name = "rdgGrpCT"

    model_config = ConfigDict(defer_build=True)
    rdg: list[RdgCt] = field(
        default_factory=list,
        metadata={
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
            "min_occurs": 1,
        },
    )
    canonical: Optional[bool] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_work: Optional[str] = field(
        default=None,
        metadata={
            "name": "annotateWork",
            "type": "Attribute",
        },
    )
    annotate_type: Optional[Union[OsisAnnotation, str]] = field(
        default=None,
        metadata={
            "name": "annotateType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    editions: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "tokens": True,
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    resp: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    type_value: Optional[str] = field(
        default=None,
        metadata={
            "name": "type",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    n: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lang: Optional[Union[str, LangValue]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    space: Optional[SpaceValue] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    script: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"([A-Z][a-z]{3}|x-[A-Za-z0-9]+)",
        },
    )
    teiform: str = field(
        const=True,
        default="rdgGrp",
        metadata={
            "name": "TEIform",
            "type": "Attribute",
        },
    )


class TitlePageCt(BaseModel):
    class Meta:
        name = "titlePageCT"

    model_config = ConfigDict(defer_build=True)
    title: list[TitleCt] = field(
        default_factory=list,
        metadata={
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
        },
    )
    contributor: list[ContributorCt] = field(
        default_factory=list,
        metadata={
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
        },
    )
    creator: list[CreatorCt] = field(
        default_factory=list,
        metadata={
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
        },
    )
    subject: list[SubjectCt] = field(
        default_factory=list,
        metadata={
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
        },
    )
    date: list[DateCt] = field(
        default_factory=list,
        metadata={
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
        },
    )
    description: list[DescriptionCt] = field(
        default_factory=list,
        metadata={
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
        },
    )
    publisher: list[PublisherCt] = field(
        default_factory=list,
        metadata={
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
        },
    )
    type_value: list[TypeCt] = field(
        default_factory=list,
        metadata={
            "name": "type",
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
        },
    )
    format: list[FormatCt] = field(
        default_factory=list,
        metadata={
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
        },
    )
    identifier: list[IdentifierCt] = field(
        default_factory=list,
        metadata={
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
        },
    )
    source: list[SourceCt] = field(
        default_factory=list,
        metadata={
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
        },
    )
    language: list[LanguageCt] = field(
        default_factory=list,
        metadata={
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
        },
    )
    relation: list[RelationCt] = field(
        default_factory=list,
        metadata={
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
        },
    )
    coverage: list[CoverageCt] = field(
        default_factory=list,
        metadata={
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
        },
    )
    p: list[PCt] = field(
        default_factory=list,
        metadata={
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
        },
    )
    figure: list[FigureCt] = field(
        default_factory=list,
        metadata={
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
        },
    )
    milestone: list[MilestoneCt] = field(
        default_factory=list,
        metadata={
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
        },
    )
    canonical: bool = field(
        default=False,
        metadata={
            "type": "Attribute",
        },
    )
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_work: Optional[str] = field(
        default=None,
        metadata={
            "name": "annotateWork",
            "type": "Attribute",
        },
    )
    annotate_type: Optional[Union[OsisAnnotation, str]] = field(
        default=None,
        metadata={
            "name": "annotateType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    editions: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "tokens": True,
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    resp: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    type_attribute: Optional[str] = field(
        default=None,
        metadata={
            "name": "type",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    n: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lang: Optional[Union[str, LangValue]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    space: Optional[SpaceValue] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    script: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"([A-Z][a-z]{3}|x-[A-Za-z0-9]+)",
        },
    )


class VerseCt(Milestoneable):
    class Meta:
        name = "verseCT"

    model_config = ConfigDict(defer_build=True)
    canonical: bool = field(
        default=True,
        metadata={
            "type": "Attribute",
        },
    )
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_work: Optional[str] = field(
        default=None,
        metadata={
            "name": "annotateWork",
            "type": "Attribute",
        },
    )
    annotate_type: Optional[Union[OsisAnnotation, str]] = field(
        default=None,
        metadata={
            "name": "annotateType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    editions: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "tokens": True,
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    resp: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    type_value: Optional[str] = field(
        default=None,
        metadata={
            "name": "type",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    n: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lang: Optional[Union[str, LangValue]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    space: Optional[SpaceValue] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    script: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"([A-Z][a-z]{3}|x-[A-Za-z0-9]+)",
        },
    )
    content: list[object] = field(
        default_factory=list,
        metadata={
            "type": "Wildcard",
            "namespace": "##any",
            "mixed": True,
            "choices": (
                {
                    "name": "a",
                    "type": ACt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "abbr",
                    "type": AbbrCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "date",
                    "type": DateCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "divineName",
                    "type": DivineNameCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "foreign",
                    "type": ForeignCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "hi",
                    "type": HiCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "index",
                    "type": IndexCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "inscription",
                    "type": InscriptionCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "lb",
                    "type": LbCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "list",
                    "type": ListCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "mentioned",
                    "type": MentionedCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestone",
                    "type": MilestoneCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestoneEnd",
                    "type": MilestoneEndCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestoneStart",
                    "type": MilestoneStartCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "name",
                    "type": NameCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "note",
                    "type": NoteCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "q",
                    "type": QCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "reference",
                    "type": ReferenceCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "seg",
                    "type": SegCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "speaker",
                    "type": SpeakerCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "title",
                    "type": TitleCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "transChange",
                    "type": TransChangeCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "w",
                    "type": WCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
            ),
        },
    )


class CastListCt(BaseModel):
    class Meta:
        name = "castListCT"

    model_config = ConfigDict(defer_build=True)
    cast_group: list[CastGroupCt] = field(
        default_factory=list,
        metadata={
            "name": "castGroup",
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
        },
    )
    canonical: Optional[bool] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_work: Optional[str] = field(
        default=None,
        metadata={
            "name": "annotateWork",
            "type": "Attribute",
        },
    )
    annotate_type: Optional[Union[OsisAnnotation, str]] = field(
        default=None,
        metadata={
            "name": "annotateType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    editions: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "tokens": True,
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    resp: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    type_value: Optional[str] = field(
        default=None,
        metadata={
            "name": "type",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    n: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lang: Optional[Union[str, LangValue]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    space: Optional[SpaceValue] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    script: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"([A-Z][a-z]{3}|x-[A-Za-z0-9]+)",
        },
    )
    teiform: str = field(
        const=True,
        default="castList",
        metadata={
            "name": "TEIform",
            "type": "Attribute",
        },
    )


class SaluteCt(Milestoneable):
    class Meta:
        name = "saluteCT"

    model_config = ConfigDict(defer_build=True)
    canonical: Optional[bool] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_work: Optional[str] = field(
        default=None,
        metadata={
            "name": "annotateWork",
            "type": "Attribute",
        },
    )
    annotate_type: Optional[Union[OsisAnnotation, str]] = field(
        default=None,
        metadata={
            "name": "annotateType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    editions: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "tokens": True,
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    resp: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    type_value: Optional[str] = field(
        default=None,
        metadata={
            "name": "type",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    n: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lang: Optional[Union[str, LangValue]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    space: Optional[SpaceValue] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    script: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"([A-Z][a-z]{3}|x-[A-Za-z0-9]+)",
        },
    )
    teiform: str = field(
        const=True,
        default="salute",
        metadata={
            "name": "TEIform",
            "type": "Attribute",
        },
    )
    content: list[object] = field(
        default_factory=list,
        metadata={
            "type": "Wildcard",
            "namespace": "##any",
            "mixed": True,
            "choices": (
                {
                    "name": "a",
                    "type": ACt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "abbr",
                    "type": AbbrCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "date",
                    "type": DateCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "divineName",
                    "type": DivineNameCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "foreign",
                    "type": ForeignCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "hi",
                    "type": HiCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "index",
                    "type": IndexCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "lb",
                    "type": LbCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "lg",
                    "type": LgCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "list",
                    "type": ListCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "mentioned",
                    "type": MentionedCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestone",
                    "type": MilestoneCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestoneEnd",
                    "type": MilestoneEndCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestoneStart",
                    "type": MilestoneStartCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "name",
                    "type": NameCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "note",
                    "type": NoteCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "p",
                    "type": PCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "q",
                    "type": QCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "reference",
                    "type": ReferenceCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "seg",
                    "type": SegCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "speaker",
                    "type": SpeakerCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "transChange",
                    "type": TransChangeCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "verse",
                    "type": VerseCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "w",
                    "type": WCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
            ),
        },
    )


class SpeechCt(Milestoneable):
    class Meta:
        name = "speechCT"

    model_config = ConfigDict(defer_build=True)
    canonical: Optional[bool] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_work: Optional[str] = field(
        default=None,
        metadata={
            "name": "annotateWork",
            "type": "Attribute",
        },
    )
    annotate_type: Optional[Union[OsisAnnotation, str]] = field(
        default=None,
        metadata={
            "name": "annotateType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    editions: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "tokens": True,
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    resp: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    type_value: Optional[str] = field(
        default=None,
        metadata={
            "name": "type",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    n: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lang: Optional[Union[str, LangValue]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    space: Optional[SpaceValue] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    script: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"([A-Z][a-z]{3}|x-[A-Za-z0-9]+)",
        },
    )
    marker: str = field(
        default="DEFAULT",
        metadata={
            "type": "Attribute",
        },
    )
    teiform: str = field(
        const=True,
        default="speech",
        metadata={
            "name": "TEIform",
            "type": "Attribute",
        },
    )
    content: list[object] = field(
        default_factory=list,
        metadata={
            "type": "Wildcard",
            "namespace": "##any",
            "mixed": True,
            "choices": (
                {
                    "name": "speech",
                    "type": ForwardRef("SpeechCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "a",
                    "type": ACt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "abbr",
                    "type": AbbrCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "chapter",
                    "type": ChapterCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "closer",
                    "type": CloserCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "date",
                    "type": DateCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "divineName",
                    "type": DivineNameCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "foreign",
                    "type": ForeignCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "hi",
                    "type": HiCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "index",
                    "type": IndexCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "inscription",
                    "type": InscriptionCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "lb",
                    "type": LbCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "lg",
                    "type": LgCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "list",
                    "type": ListCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "mentioned",
                    "type": MentionedCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestone",
                    "type": MilestoneCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestoneEnd",
                    "type": MilestoneEndCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestoneStart",
                    "type": MilestoneStartCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "name",
                    "type": NameCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "note",
                    "type": NoteCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "p",
                    "type": PCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "q",
                    "type": QCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "reference",
                    "type": ReferenceCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "salute",
                    "type": SaluteCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "seg",
                    "type": SegCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "signed",
                    "type": SignedCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "speaker",
                    "type": SpeakerCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "table",
                    "type": TableCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "title",
                    "type": TitleCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "transChange",
                    "type": TransChangeCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "verse",
                    "type": VerseCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "w",
                    "type": WCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
            ),
        },
    )


class WorkCt(BaseModel):
    class Meta:
        name = "workCT"

    model_config = ConfigDict(defer_build=True)
    title: list[TitleCt] = field(
        default_factory=list,
        metadata={
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
        },
    )
    contributor: list[ContributorCt] = field(
        default_factory=list,
        metadata={
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
        },
    )
    creator: list[CreatorCt] = field(
        default_factory=list,
        metadata={
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
        },
    )
    subject: list[SubjectCt] = field(
        default_factory=list,
        metadata={
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
        },
    )
    date: list[DateCt] = field(
        default_factory=list,
        metadata={
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
        },
    )
    description: list[DescriptionCt] = field(
        default_factory=list,
        metadata={
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
        },
    )
    publisher: list[PublisherCt] = field(
        default_factory=list,
        metadata={
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
        },
    )
    type_value: list[TypeCt] = field(
        default_factory=list,
        metadata={
            "name": "type",
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
        },
    )
    format: list[FormatCt] = field(
        default_factory=list,
        metadata={
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
        },
    )
    identifier: list[IdentifierCt] = field(
        default_factory=list,
        metadata={
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
        },
    )
    source: list[SourceCt] = field(
        default_factory=list,
        metadata={
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
        },
    )
    language: list[LanguageCt] = field(
        default_factory=list,
        metadata={
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
        },
    )
    relation: list[RelationCt] = field(
        default_factory=list,
        metadata={
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
        },
    )
    coverage: list[CoverageCt] = field(
        default_factory=list,
        metadata={
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
        },
    )
    rights: list[RightsCt] = field(
        default_factory=list,
        metadata={
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
        },
    )
    scope: list[ScopeCt] = field(
        default_factory=list,
        metadata={
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
        },
    )
    cast_list: list[CastListCt] = field(
        default_factory=list,
        metadata={
            "name": "castList",
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
        },
    )
    tei_header: Optional[TeiHeaderCt] = field(
        default=None,
        metadata={
            "name": "teiHeader",
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
        },
    )
    ref_system: list[RefSystemCt] = field(
        default_factory=list,
        metadata={
            "name": "refSystem",
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
        },
    )
    osis_work: str = field(
        metadata={
            "name": "osisWork",
            "type": "Attribute",
            "required": True,
            "pattern": r"((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?",
        }
    )
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_work: Optional[str] = field(
        default=None,
        metadata={
            "name": "annotateWork",
            "type": "Attribute",
        },
    )
    annotate_type: Optional[Union[OsisAnnotation, str]] = field(
        default=None,
        metadata={
            "name": "annotateType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    editions: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "tokens": True,
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    resp: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    type_attribute: Optional[str] = field(
        default=None,
        metadata={
            "name": "type",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    n: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lang: Optional[Union[str, LangValue]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    space: Optional[SpaceValue] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    script: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"([A-Z][a-z]{3}|x-[A-Za-z0-9]+)",
        },
    )


class CorpusHeaderCt(BaseModel):
    class Meta:
        name = "corpusHeaderCT"

    model_config = ConfigDict(defer_build=True)
    revision_desc: list[RevisionDescCt] = field(
        default_factory=list,
        metadata={
            "name": "revisionDesc",
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
        },
    )
    work: list[WorkCt] = field(
        default_factory=list,
        metadata={
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
            "min_occurs": 1,
        },
    )
    teiform: str = field(
        const=True,
        default="teiHeader",
        metadata={
            "name": "TEIform",
            "type": "Attribute",
        },
    )
    canonical: bool = field(
        default=False,
        metadata={
            "type": "Attribute",
        },
    )


class DivCt(Milestoneable):
    class Meta:
        name = "divCT"

    model_config = ConfigDict(defer_build=True)
    canonical: bool = field(
        default=False,
        metadata={
            "type": "Attribute",
        },
    )
    osis_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    scope: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    type_value: Optional[Union[OsisDivs, str]] = field(
        default=None,
        metadata={
            "name": "type",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    annotate_work: Optional[str] = field(
        default=None,
        metadata={
            "name": "annotateWork",
            "type": "Attribute",
        },
    )
    annotate_type: Optional[Union[OsisAnnotation, str]] = field(
        default=None,
        metadata={
            "name": "annotateType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    editions: list[str] = field(
        default_factory=list,
        metadata={
            "type": "Attribute",
            "tokens": True,
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    resp: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    n: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
        },
    )
    lang: Optional[Union[str, LangValue]] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    space: Optional[SpaceValue] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    script: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "pattern": r"([A-Z][a-z]{3}|x-[A-Za-z0-9]+)",
        },
    )
    teiform: str = field(
        const=True,
        default="div",
        metadata={
            "name": "TEIform",
            "type": "Attribute",
        },
    )
    content: list[object] = field(
        default_factory=list,
        metadata={
            "type": "Wildcard",
            "namespace": "##any",
            "mixed": True,
            "choices": (
                {
                    "name": "titlePage",
                    "type": TitlePageCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "a",
                    "type": ACt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "abbr",
                    "type": AbbrCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "chapter",
                    "type": ChapterCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "closer",
                    "type": CloserCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "date",
                    "type": DateCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "div",
                    "type": ForwardRef("DivCt"),
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "divineName",
                    "type": DivineNameCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "figure",
                    "type": FigureCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "foreign",
                    "type": ForeignCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "hi",
                    "type": HiCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "index",
                    "type": IndexCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "inscription",
                    "type": InscriptionCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "lb",
                    "type": LbCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "lg",
                    "type": LgCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "list",
                    "type": ListCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "mentioned",
                    "type": MentionedCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestone",
                    "type": MilestoneCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestoneEnd",
                    "type": MilestoneEndCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "milestoneStart",
                    "type": MilestoneStartCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "name",
                    "type": NameCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "note",
                    "type": NoteCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "p",
                    "type": PCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "q",
                    "type": QCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "reference",
                    "type": ReferenceCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "salute",
                    "type": SaluteCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "seg",
                    "type": SegCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "signed",
                    "type": SignedCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "speaker",
                    "type": SpeakerCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "speech",
                    "type": SpeechCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "table",
                    "type": TableCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "title",
                    "type": TitleCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "transChange",
                    "type": TransChangeCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "verse",
                    "type": VerseCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
                {
                    "name": "w",
                    "type": WCt,
                    "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
                },
            ),
        },
    )


class HeaderCt(BaseModel):
    class Meta:
        name = "headerCT"

    model_config = ConfigDict(defer_build=True)
    revision_desc: list[RevisionDescCt] = field(
        default_factory=list,
        metadata={
            "name": "revisionDesc",
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
        },
    )
    work: list[WorkCt] = field(
        default_factory=list,
        metadata={
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
            "min_occurs": 1,
        },
    )
    work_prefix: list[WorkPrefixCt] = field(
        default_factory=list,
        metadata={
            "name": "workPrefix",
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
        },
    )
    teiform: str = field(
        const=True,
        default="teiHeader",
        metadata={
            "name": "TEIform",
            "type": "Attribute",
        },
    )
    canonical: bool = field(
        default=False,
        metadata={
            "type": "Attribute",
        },
    )


class OsisTextCt(BaseModel):
    class Meta:
        name = "osisTextCT"

    model_config = ConfigDict(defer_build=True)
    header: HeaderCt = field(
        metadata={
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
            "required": True,
        }
    )
    title_page: Optional[TitlePageCt] = field(
        default=None,
        metadata={
            "name": "titlePage",
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
        },
    )
    div: list[DivCt] = field(
        default_factory=list,
        metadata={
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
        },
    )
    annotate_ref: list[str] = field(
        default_factory=list,
        metadata={
            "name": "annotateRef",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_|(\\[^\s]))+)(\.(\p{L}|\p{N}|_|(\\[^\s]))*)*)+)(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?(@(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?",
            "tokens": True,
        },
    )
    canonical: bool = field(
        default=True,
        metadata={
            "type": "Attribute",
        },
    )
    id: Optional[str] = field(
        default=None,
        metadata={
            "name": "ID",
            "type": "Attribute",
        },
    )
    osis_id: list[str] = field(
        default_factory=list,
        metadata={
            "name": "osisID",
            "type": "Attribute",
            "pattern": r"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?(!((\p{L}|\p{N}|_|(\\[^\s]))+)((\.(\p{L}|\p{N}|_|(\\[^\s]))+)*)?)?",
            "tokens": True,
        },
    )
    osis_idwork: str = field(
        metadata={
            "name": "osisIDWork",
            "type": "Attribute",
            "required": True,
            "pattern": r"((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?",
        }
    )
    osis_ref_work: str = field(
        default="Bible",
        metadata={
            "name": "osisRefWork",
            "type": "Attribute",
            "pattern": r"((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?",
        },
    )
    type_value: Optional[str] = field(
        default=None,
        metadata={
            "name": "type",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    sub_type: Optional[str] = field(
        default=None,
        metadata={
            "name": "subType",
            "type": "Attribute",
            "pattern": r"x-([^\s])+",
        },
    )
    lang: Union[str, LangValue] = field(
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
            "required": True,
        }
    )
    space: SpaceValue = field(
        default=SpaceValue.DEFAULT,
        metadata={
            "type": "Attribute",
            "namespace": "http://www.w3.org/XML/1998/namespace",
        },
    )
    teiform: str = field(
        const=True,
        default="text",
        metadata={
            "name": "TEIform",
            "type": "Attribute",
        },
    )


class OsisCorpusCt(BaseModel):
    class Meta:
        name = "osisCorpusCT"

    model_config = ConfigDict(defer_build=True)
    header: Optional[CorpusHeaderCt] = field(
        default=None,
        metadata={
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
        },
    )
    title_page: Optional[TitlePageCt] = field(
        default=None,
        metadata={
            "name": "titlePage",
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
        },
    )
    osis_text: list[OsisTextCt] = field(
        default_factory=list,
        metadata={
            "name": "osisText",
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
            "min_occurs": 1,
        },
    )
    teiform: str = field(
        const=True,
        default="teiCorpus.2",
        metadata={
            "name": "TEIform",
            "type": "Attribute",
        },
    )


class OsisCt(BaseModel):
    class Meta:
        name = "osisCT"

    model_config = ConfigDict(defer_build=True)
    osis_corpus: Optional[OsisCorpusCt] = field(
        default=None,
        metadata={
            "name": "osisCorpus",
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
        },
    )
    osis_text: Optional[OsisTextCt] = field(
        default=None,
        metadata={
            "name": "osisText",
            "type": "Element",
            "namespace": "http://www.bibletechnologies.net/2003/OSIS/namespace",
        },
    )
    teiform: str = field(
        const=True,
        default="TEI.2",
        metadata={
            "name": "TEIform",
            "type": "Attribute",
        },
    )


class Osis(OsisCt):
    class Meta:
        name = "osis"
        namespace = "http://www.bibletechnologies.net/2003/OSIS/namespace"

    model_config = ConfigDict(defer_build=True)
