Describe element-type declarations in DTDs and explain how they define the structure of an XML document. Provide examples.

Element-type declarations in Document Type Definitions (DTDs) are crucial for defining the structure of an XML document. DTDs specify the legal building blocks of an XML document, detailing what elements can appear, how they are nested, and the type of data they can contain. Essentially, they serve as a blueprint that validates the structure and content of the XML document according to defined rules.

### Basic Structure of DTDs

A DTD can be declared internally within an XML document or externally in a separate file. Element-type declarations are written using the `<!ELEMENT>` directive.

### Syntax of Element-Type Declarations

The basic syntax for an element-type declaration is:
```xml
<!ELEMENT elementName contentModel>
```

- `elementName`: The name of the element being defined.
- `contentModel`: Specifies the type of content the element can contain. This can be text, other elements, or a combination of both.

### Content Models

The `contentModel` can consist of the following forms:

1. **Empty Element**: 
   - Syntax: `<!ELEMENT elementName EMPTY>`
   - Represents an element that does not contain any child elements or text.
   - Example: 
     ```xml
     <!ELEMENT line EMPTY>
     ```

2. **Mixed Content**:
   - Syntax: `<!ELEMENT elementName (#PCDATA|elementName)*>`
   - Allows the element to contain both text and child elements.
   - Example:
     ```xml
     <!ELEMENT paragraph (#PCDATA|sentence)*>
     ```

3. **Child Elements Only**:
   - These can be defined using sequences, alternatives, or a combination of both:
   - **Sequence**: Child elements must appear in a specific order.
     - Syntax: `<!ELEMENT parentName (child1, child2, child3)>`
     - Example:
       ```xml
       <!ELEMENT book (title, author, year)>
       ```
   - **Alternatives**: An element can contain one of several possible child elements.
     - Syntax: `<!ELEMENT parentName (child1 | child2 | child3)>`
     - Example:
       ```xml
       <!ELEMENT animal (cat | dog | bird)>
       ```
   - **Mixing Sequences and Alternatives**:
     - Elements can combine multiple types.
     - Example:
       ```xml
       <!ELEMENT library (book*, magazine?)>
       ```

### Example DTD

Here is a complete example that defines a simple XML structure for a library system:

```xml
<?xml version="1.0"?>
<!DOCTYPE library [
  <!ELEMENT library (book+)>
  <!ELEMENT book (title, author, year)>
  <!ELEMENT title (#PCDATA)>
  <!ELEMENT author (#PCDATA)>
  <!ELEMENT year (#PCDATA)>
]>
<library>
    <book>
        <title>Learning XML</title>
        <author>John Doe</author>
        <year>2023</year>
    </book>
    <book>
        <title>Understanding DTDs</title>
        <author>Jane Smith</author>
        <year>2023</year>
    </book>
</library>
```

### Explanation of the Example

- The DTD specifies that a `library` element must contain one or more `book` elements (`(book+)`).
- A `book` element must contain a `title`, an `author`, and a `year` element in that order.
- Each of the `title`, `author`, and `year` elements can contain parsed character data (`#PCDATA`), which refers to text content.

### Validity Checking

When an XML document is validated against its DTD, the parser checks whether the document adheres to the rules defined in the DTD. This ensures that the document is well-formed and that its structure matches the expectations set by the DTD.

In summary, element-type declarations in DTDs are foundational for defining the structure of XML documents, enforcing rules for how elements are nested, what types of data they can contain, and overall ensuring data integrity.