BibInternal.entriesConstant
    const entries = [
        :article,
        :book,
        :booklet,
        :inbook,
        :incollection,
        :inproceedings,
        :manual,
        :mastersthesis,
        :misc,
        :phdthesis,
        :proceedings,
        :techreport,
        :unpublished,
    ]

    List of possible entries (currently based on bibtex). Keep it sorted for readability.

    BibInternal.fieldsConstant
    const fields = [
        :address,
        :annote,
        :archivePrefix,
        :author,
        :booktitle,
        :chapter,
        :crossref,
        :edition,
        :editor,
        :eprint,
        :howpublished,
        :institution,
        :journal,
        :key,
        :month,
        :note,
        :number,
        :organization,
        :pages,
        :primaryClass,
        :publisher,
        :school,
        :series,
        :title,
        :type,
        :volume,
        :year
    ]

    List of possible fields (currently based on bibtex). Keep it sorted for readability

    BibInternal.rulesConstant
    const rules = Dict([
        "article"       => ["author", "journal", "title", "year"]
        "book"          => [("author", "editor"), "publisher", "title", "year"]
        "booklet"       => ["title"]
        "eprint"        => ["author", "eprint", "title", "year"]
        "inbook"        => [("author", "editor"), ("chapter", "pages"), "publisher", "title", "year"]
        "incollection"  => ["author", "booktitle", "publisher", "title", "year"]
        "inproceedings" => ["author", "booktitle", "title", "year"]
        "manual"        => ["title"]
        "mastersthesis" => ["author", "school", "title", "year"]
        "misc"          => []
        "phdthesis"     => ["author", "school", "title", "year"]
        "proceedings"   => ["title", "year"]
        "techreport"    => ["author", "institution", "title", "year"]
        "unpublished"   => ["author", "note", "title"]
    ])

    List of BibTeX rules bases on the entry type. A field value as a singleton represents a required field. A pair of values represents mutually exclusive required fields.

    BibInternal.AccessType
    struct Access
        doi::String
        howpublished::String
        url::String
    end

    Store the online access of an entry as a String. Handles the fields doi and url and the arXiv entries. For additional fields or entries, please fill an issue or make a pull request.

    BibInternal.AccessMethod
    Access(fields::Fields)

    Construct the online access information based on the entry fields.

    BibInternal.DateType
    struct Date
        day::String
        month::String
        year::String
    end

    Store the date information as day, month, and year.

    BibInternal.DateMethod
    Date(fields::Fields)

    Construct the date information based on the entry fields.

    BibInternal.EntryType
    struct Entry <: AbstractEntry
        access::Access
        authors::Names
        booktitle::String
        date::Date
        editors::Names
        eprint::Eprint
        id::String
        in::In
        fields::Dict{String,String}
        title::String
        type::String
    end

    Generic Entry type. If some construction rules are required, it should be done beforehand. Check bibtex.jl as the example of rules implementation for BibTeX format.

    BibInternal.EntryMethod
    Entry(id::String, fields::Fields)

    Construct an entry with a unique id and a list of Fields.

    BibInternal.EprintType
    struct Eprint
        archive_prefix::String
        eprint::String
        primary_class::String
    end

    Store the information related to arXiv eprint format.

    BibInternal.EprintMethod
    Eprint(fields::Fields)

    Construct the eprint arXiv information based on the entry fields. Handle old and current arXiv format.

    BibInternal.FieldsType

    Fields = Dict{String, String}. Stores the fields name => value of an entry.

    BibInternal.InType
    struct In
        address::String
        chapter::String
        edition::String
        institution::String
        journal::String
        number::String
        organization::String
        pages::String
        publisher::String
        school::String
        series::String
        volume::String
    end

    Store all the information related to how an entry was published.

    BibInternal.InMethod
    In(fields::Fields)

    Construct the information of how an entry was published based on its fields

    BibInternal.NameMethod
    Name(str::String)

    Decompose without ambiguities a name as particle (optional) last, junior (optional), first middle (optional) based on BibTeX possible input. As for BibTeX, the decomposition of a name in the form of first last is also possible, but ambiguities can occur.

    Base.islessMethod
    Base.isless(a::BibInternal.Date,b::BibInternal.Date)::Bool

    Function to check for a < b on BibInternal.Date data types.

    This function will throw an ArgumentError if the year can not parsed into Int. If it is not possible to parse month or day to Int those entries will be silently ignored for comparison. This function will not check if the date fields are given in a correct format all fields are parsed into and compared as Int (no checking if date format is correct or valid!).

    Note:

    The silent ignoring of not parseable month or day fields will lead to misbehaviour if using comparators like == or !==!

    Base.islessMethod
    Base.isless(a::BibInternal.Name,b::BibInternal.Name)::Bool

    Function to check for a < b on BibInternal.Name data types.

    This function will check the fields last, first and middle in this order of priority. The other fields are ignored for now. The field comparison is done by string comparison no advanced alphabetizing rules are used for now.

    Note:

    The silent ignoring of the other fields might lead to misbehaviour if using comparators like == or !==!

    BibInternal.arxive_urlMethod
    arxive_url(fields::Fields)

    Make an arxiv url from an eprint entry. Work with both old and current arxiv BibTeX format.

    BibInternal.erase_spacesMethod
    erase_spaces(str::String)

    Erase extra spaces, i.e. r"[ ]+", from str and return a new string.

    BibInternal.get_delete!Method
    get_delete!(fields::Fields, key::String)

    Get the value of a field and delete it afterward.

    BibInternal.make_bibtex_entryMethod
    make_bibtex_entry(id::String, fields::Fields)

    Make an entry if the entry follows the BibTeX guidelines. Throw an error otherwise.

    BibInternal.namesMethod
    names(str::String)

    Decompose into parts a list of names in BibTeX compatible format. That is names separated by and.

    BibInternal.spaceMethod
    space(field::Symbol)

    Return the amount of spaces needed to export entries, for instance to BibTeX format.