⏳ This skill is pending AI review.

Scores will appear once the review pipeline completes.

version unknown

docx

appautomaton@appautomaton⭐ 184 stars· last commit 1mo ago· 0 open issues

Create, edit, review, and read Word documents (.docx), including tracked changes (redlines), comments, footnotes, tables, images, headers and page setup. Use when a task produces or modifies a .docx, reviews or redlines one, or needs its text, comments or tracked changes read.

Choose how to use this skill

You do not need every option. Choose the path your AI client supports. The stable page stays the same; versioned files are immutable.

1. Native installer

This listing has no registered native installer command. Use the complete package or source fallback below, depending on what your client supports.

Do not guess an installer command or replace an existing version without reviewing the diff.

2. Complete package recommended

Download the ZIP when available. It includes SKILL.md plus the references, security notes and version metadata.

No complete ProSkills package is published for this listing yet.

3. Prompt-only

Copy the prompt above when the agent can read the stable page or when you want to adopt the workflow without installing a skill.

Need only the instruction file?

Download SKILL.md only if your client requires a single file. The complete ZIP is safer for a full installation because it preserves the references and release context.

No path installs or executes anything by itself. Your agent still needs access to the project files. Before updating, compare the installed version and review the diff.

—/10

// RATINGS

⭐GitHub Stars
⭐⭐⭐ 184 on GitHubGitHub ↗

Popular

🟢ProSkills Score
—
📍

Not yet listed on ClawHub or SkillsMP

// README

Document Processing Skills

English | 中文

A collection of Claude Code / Codex skills for document manipulation — PDF extraction/forms, Excel analysis/formulas, Word, and PowerPoint.

Quick start

Claude Code, as a plugin

Two commands inside Claude Code, no cloning:

/plugin marketplace add appautomaton/document-SKILLs
/plugin install document-skills@appautomaton-skills

Skills are then invoked as document-skills:pdf, document-skills:docx, and so on. The system tools under Dependencies are still required; the docx and pptx skills install their Node packages the first time they need them.

Any agent, via symlinks

[!TIP] Clone this repo anywhere you keep your skills, then symlink each skill into your agent's skills directory.

git clone https://github.com/appautomaton/document-SKILLs.git ~/skills/documents
cd ~/skills/documents

# Claude Code
for s in docx pdf pptx xlsx; do
  ln -s "$(pwd)/$s" ~/.claude/skills/$s
done

# Codex
for s in docx pdf pptx xlsx; do
  ln -s "$(pwd)/$s" ~/.codex/skills/$s
done

Skills

SkillWhat it does
docxCreate, redline, comment on, and read Word documents — real tracked changes, checked so no edit goes untracked
pdfExtract text/tables, fill fillable and flat forms, merge/split/stamp, OCR scanned pages
pptxBuild decks from HTML as native slides, fill templates, duplicate and reorder slides, edit speaker notes
xlsxCreate/edit workbooks with live formulas, then recalculate and get every error, circular reference, and broken function by cell

Every workflow checks its own output before handing it back: workbooks are recalculated and scanned for errors, Word and PowerPoint files are validated against the OOXML schemas, and documents, PDFs and decks are rendered so the agent can look at them.

Dependencies

[!NOTE] Python scripts use uv + PEP 723 inline metadata — no virtual environments or pip install needed. Just uv run.

System tools:

# macOS: one command via the repo Brewfile.
# Installs uv and node only if missing, optional tools are commented in the file.
brew bundle

# Linux
sudo apt-get install -y pandoc poppler-utils libreoffice
sudo apt-get install -y tesseract-ocr   # optional, OCR of scanned PDFs

Node.js packages (docx and pptx skills only):

cd docx && npm install
cd ../pptx && npm install

Development

tests/ runs every script through uv run, the way an agent does. See AGENTS.md.

License

MIT — see LICENSE.


🤖 Checkout linux.do for more fun stuff about AI!

// HOW IT'S BUILT

// FILES

63 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.

  • docx/SKILL.md4.5 KB647ba22edcd3upstream ↗
    ---
    name: docx
    description: Create, edit, review, and read Word documents (.docx), including tracked changes (redlines), comments, footnotes, tables, images, headers and page setup. Use when a task produces or modifies a .docx, reviews or redlines one, or needs its text, comments or tracked changes read.
    ---
    
    # Word documents
    
    You already know Word's features. This skill adds what you can't see from the code: a library that makes tracked changes and comments correctly, validation that catches untracked edits, a way to see pages as a reader will, and the docx-js and OOXML behaviours that silently produce broken files.
    
    ## Running scripts
    
    `<skill>` is the directory containing this file. Run bundled scripts by absolute path from the user's working directory, so relative paths to their files keep working:
    
    ```bash
    uv run <skill>/ooxml/scripts/unpack.py contract.docx unpacked
    ```
    
    Run Python you write with its dependencies declared, either `uv run --with defusedxml script.py` or a PEP 723 header. Run Node scripts as `NODE_PATH=<skill>/node_modules node build.js`; if `<skill>/node_modules` is missing, run `npm install` in `<skill>` once. Rendering pages needs LibreOffice (`soffice`) and poppler (`pdftoppm`); reading needs pandoc.
    
    ## Choosing a workflow
    
    | Task | Use |
    |---|---|
    | Read the text | `pandoc --track-changes=all file.docx -t markdown`. It also shows tracked changes and comments. Use `accept` or `reject` instead of `all` to see either outcome. |
    | Create a document | docx-js: read [docx-js.md](docx-js.md) first. It covers the page size, style and image behaviours that otherwise break the file. |
    | Edit someone else's document, or anything legal, academic, business or official | Tracked changes, so every edit is reviewable: the redlining workflow below. |
    | Small edits to a document you created in this session | The same library, untracked. Make the edits, then call `doc.save(require_tracking=False)`, which still checks the schema. For larger changes, regenerate the file with docx-js. |
    | Comments, metadata, embedded media, raw structure | Unpack and read the XML; [ooxml.md](ooxml.md) has the patterns. |
    
    ## Redlining workflow
    
    1. **Read.** Convert the document with pandoc (above) and list every change you will make. Locate each one by its surrounding text, never by markdown line numbers, which have no relation to the XML.
    2. **Unpack.** `uv run <skill>/ooxml/scripts/unpack.py contract.docx unpacked` prints a suggested RSID. Pass it as `Document(..., rsid=...)` so the session's edits share one revision ID.
    3. **Edit.** Read [ooxml.md](ooxml.md), then write a script that uses the `Document` library. `tracked_replace(old, new)` handles most edits: it finds text across runs and marks only the words that differ. Work in batches of related changes, a few to a dozen per script, so a failure is easy to locate. Grep `unpacked/word/document.xml` again before each batch, because line numbers move after every save.
    4. **Save.** `doc.save()` refuses to write a document with untracked edits, or with XML that breaks the schema, and prints what differs. Fix the script rather than skipping validation.
    5. **Pack.** `uv run <skill>/ooxml/scripts/pack.py unpacked reviewed.docx` repacks the file and checks that LibreOffice can open it.
    6. **Verify.** Run `pandoc --track-changes=all reviewed.docx -t markdown` and confirm every intended change appears and nothing else changed. Then check the output (below).
    
    To accept or reject existing changes, call `doc.accept_all_changes()` or `doc.reject_all_changes()` before making edits of your own.
    
    ## Checking the output
    
    1. **Validate.** `uv run <skill>/ooxml/scripts/validate.py reviewed.docx --original contract.docx` checks the schema, and that every change from the original is tracked; `doc.save()` runs the same checks. Pass `--author NAME` to let that author's earlier insertions be edited directly. For a document generated from scratch, leave out `--original` to check the schema alone.
    2. **Look.** `uv run <skill>/ooxml/scripts/render.py reviewed.docx pages` prints one PNG path per page (`--pages 2-4` for a range). Read them before delivering a document you created or restructured. LibreOffice renders a docx-js table of contents empty; Word fills it in when it opens the file.
    
    ## Pitfalls that fail silently
    
    - **Partial edits inside other authors' changes.** To remove text inside someone else's insertion, nest your `<w:del>` inside it. Never edit their text directly.
    - **pandoc as an editor.** It rewrites the whole document and drops formatting, comments and tracked changes. Use it to read, never to produce the deliverable.
    
  • docx/scripts/__init__.py65 Bbf9c56272f9cupstream ↗
    # Make scripts directory a package for relative imports in tests
    
  • docx/scripts/document.py75 KB4975823545efupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • docx/scripts/templates/comments.xml2.6 KBb5dace0ef989upstream ↗
    <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
    <w:comments xmlns:wpc="http://schemas.microsoft.com/office/word/2010/wordprocessingCanvas" xmlns:cx="http://schemas.microsoft.com/office/drawing/2014/chartex" xmlns:cx1="http://schemas.microsoft.com/office/drawing/2015/9/8/chartex" xmlns:cx2="http://schemas.microsoft.com/office/drawing/2015/10/21/chartex" xmlns:cx3="http://schemas.microsoft.com/office/drawing/2016/5/9/chartex" xmlns:cx4="http://schemas.microsoft.com/office/drawing/2016/5/10/chartex" xmlns:cx5="http://schemas.microsoft.com/office/drawing/2016/5/11/chartex" xmlns:cx6="http://schemas.microsoft.com/office/drawing/2016/5/12/chartex" xmlns:cx7="http://schemas.microsoft.com/office/drawing/2016/5/13/chartex" xmlns:cx8="http://schemas.microsoft.com/office/drawing/2016/5/14/chartex" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" xmlns:aink="http://schemas.microsoft.com/office/drawing/2016/ink" xmlns:am3d="http://schemas.microsoft.com/office/drawing/2017/model3d" xmlns:o="urn:schemas-microsoft-com:office:office" xmlns:oel="http://schemas.microsoft.com/office/2019/extlst" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" xmlns:m="http://schemas.openxmlformats.org/officeDocument/2006/math" xmlns:v="urn:schemas-microsoft-com:vml" xmlns:wp14="http://schemas.microsoft.com/office/word/2010/wordprocessingDrawing" xmlns:wp="http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing" xmlns:w10="urn:schemas-microsoft-com:office:word" xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main" xmlns:w14="http://schemas.microsoft.com/office/word/2010/wordml" xmlns:w15="http://schemas.microsoft.com/office/word/2012/wordml" xmlns:w16cex="http://schemas.microsoft.com/office/word/2018/wordml/cex" xmlns:w16cid="http://schemas.microsoft.com/office/word/2016/wordml/cid" xmlns:w16="http://schemas.microsoft.com/office/word/2018/wordml" xmlns:w16du="http://schemas.microsoft.com/office/word/2023/wordml/word16du" xmlns:w16sdtdh="http://schemas.microsoft.com/office/word/2020/wordml/sdtdatahash" xmlns:w16sdtfl="http://schemas.microsoft.com/office/word/2024/wordml/sdtformatlock" xmlns:w16se="http://schemas.microsoft.com/office/word/2015/wordml/symex" xmlns:wpg="http://schemas.microsoft.com/office/word/2010/wordprocessingGroup" xmlns:wpi="http://schemas.microsoft.com/office/word/2010/wordprocessingInk" xmlns:wne="http://schemas.microsoft.com/office/word/2006/wordml" xmlns:wps="http://schemas.microsoft.com/office/word/2010/wordprocessingShape" mc:Ignorable="w14 w15 w16se w16cid w16 w16cex w16sdtdh w16sdtfl w16du wp14">
    </w:comments>
  • docx/scripts/templates/commentsExtended.xml2.6 KBb4cf23e35691upstream ↗
    <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
    <w15:commentsEx xmlns:wpc="http://schemas.microsoft.com/office/word/2010/wordprocessingCanvas" xmlns:cx="http://schemas.microsoft.com/office/drawing/2014/chartex" xmlns:cx1="http://schemas.microsoft.com/office/drawing/2015/9/8/chartex" xmlns:cx2="http://schemas.microsoft.com/office/drawing/2015/10/21/chartex" xmlns:cx3="http://schemas.microsoft.com/office/drawing/2016/5/9/chartex" xmlns:cx4="http://schemas.microsoft.com/office/drawing/2016/5/10/chartex" xmlns:cx5="http://schemas.microsoft.com/office/drawing/2016/5/11/chartex" xmlns:cx6="http://schemas.microsoft.com/office/drawing/2016/5/12/chartex" xmlns:cx7="http://schemas.microsoft.com/office/drawing/2016/5/13/chartex" xmlns:cx8="http://schemas.microsoft.com/office/drawing/2016/5/14/chartex" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" xmlns:aink="http://schemas.microsoft.com/office/drawing/2016/ink" xmlns:am3d="http://schemas.microsoft.com/office/drawing/2017/model3d" xmlns:o="urn:schemas-microsoft-com:office:office" xmlns:oel="http://schemas.microsoft.com/office/2019/extlst" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" xmlns:m="http://schemas.openxmlformats.org/officeDocument/2006/math" xmlns:v="urn:schemas-microsoft-com:vml" xmlns:wp14="http://schemas.microsoft.com/office/word/2010/wordprocessingDrawing" xmlns:wp="http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing" xmlns:w10="urn:schemas-microsoft-com:office:word" xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main" xmlns:w14="http://schemas.microsoft.com/office/word/2010/wordml" xmlns:w15="http://schemas.microsoft.com/office/word/2012/wordml" xmlns:w16cex="http://schemas.microsoft.com/office/word/2018/wordml/cex" xmlns:w16cid="http://schemas.microsoft.com/office/word/2016/wordml/cid" xmlns:w16="http://schemas.microsoft.com/office/word/2018/wordml" xmlns:w16du="http://schemas.microsoft.com/office/word/2023/wordml/word16du" xmlns:w16sdtdh="http://schemas.microsoft.com/office/word/2020/wordml/sdtdatahash" xmlns:w16sdtfl="http://schemas.microsoft.com/office/word/2024/wordml/sdtformatlock" xmlns:w16se="http://schemas.microsoft.com/office/word/2015/wordml/symex" xmlns:wpg="http://schemas.microsoft.com/office/word/2010/wordprocessingGroup" xmlns:wpi="http://schemas.microsoft.com/office/word/2010/wordprocessingInk" xmlns:wne="http://schemas.microsoft.com/office/word/2006/wordml" xmlns:wps="http://schemas.microsoft.com/office/word/2010/wordprocessingShape" mc:Ignorable="w14 w15 w16se w16cid w16 w16cex w16sdtdh w16sdtfl w16du wp14">
    </w15:commentsEx>
  • docx/scripts/templates/commentsExtensible.xml2.7 KBe32a05e0c3ceupstream ↗
    <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
    <w16cex:commentsExtensible xmlns:wpc="http://schemas.microsoft.com/office/word/2010/wordprocessingCanvas" xmlns:cx="http://schemas.microsoft.com/office/drawing/2014/chartex" xmlns:cx1="http://schemas.microsoft.com/office/drawing/2015/9/8/chartex" xmlns:cx2="http://schemas.microsoft.com/office/drawing/2015/10/21/chartex" xmlns:cx3="http://schemas.microsoft.com/office/drawing/2016/5/9/chartex" xmlns:cx4="http://schemas.microsoft.com/office/drawing/2016/5/10/chartex" xmlns:cx5="http://schemas.microsoft.com/office/drawing/2016/5/11/chartex" xmlns:cx6="http://schemas.microsoft.com/office/drawing/2016/5/12/chartex" xmlns:cx7="http://schemas.microsoft.com/office/drawing/2016/5/13/chartex" xmlns:cx8="http://schemas.microsoft.com/office/drawing/2016/5/14/chartex" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" xmlns:aink="http://schemas.microsoft.com/office/drawing/2016/ink" xmlns:am3d="http://schemas.microsoft.com/office/drawing/2017/model3d" xmlns:o="urn:schemas-microsoft-com:office:office" xmlns:oel="http://schemas.microsoft.com/office/2019/extlst" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" xmlns:m="http://schemas.openxmlformats.org/officeDocument/2006/math" xmlns:v="urn:schemas-microsoft-com:vml" xmlns:wp14="http://schemas.microsoft.com/office/word/2010/wordprocessingDrawing" xmlns:wp="http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing" xmlns:w10="urn:schemas-microsoft-com:office:word" xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main" xmlns:w14="http://schemas.microsoft.com/office/word/2010/wordml" xmlns:w15="http://schemas.microsoft.com/office/word/2012/wordml" xmlns:w16cex="http://schemas.microsoft.com/office/word/2018/wordml/cex" xmlns:w16cid="http://schemas.microsoft.com/office/word/2016/wordml/cid" xmlns:w16="http://schemas.microsoft.com/office/word/2018/wordml" xmlns:w16du="http://schemas.microsoft.com/office/word/2023/wordml/word16du" xmlns:w16sdtdh="http://schemas.microsoft.com/office/word/2020/wordml/sdtdatahash" xmlns:w16sdtfl="http://schemas.microsoft.com/office/word/2024/wordml/sdtformatlock" xmlns:w16se="http://schemas.microsoft.com/office/word/2015/wordml/symex" xmlns:wpg="http://schemas.microsoft.com/office/word/2010/wordprocessingGroup" xmlns:wpi="http://schemas.microsoft.com/office/word/2010/wordprocessingInk" xmlns:wne="http://schemas.microsoft.com/office/word/2006/wordml" xmlns:wps="http://schemas.microsoft.com/office/word/2010/wordprocessingShape" xmlns:cr="http://schemas.microsoft.com/office/comments/2020/reactions" mc:Ignorable="w14 w15 w16se w16cid w16 w16cex w16sdtdh w16sdtfl cr w16du wp14">
    </w16cex:commentsExtensible>
  • docx/scripts/templates/commentsIds.xml2.6 KBd04bc8e06dfdupstream ↗
    <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
    <w16cid:commentsIds xmlns:wpc="http://schemas.microsoft.com/office/word/2010/wordprocessingCanvas" xmlns:cx="http://schemas.microsoft.com/office/drawing/2014/chartex" xmlns:cx1="http://schemas.microsoft.com/office/drawing/2015/9/8/chartex" xmlns:cx2="http://schemas.microsoft.com/office/drawing/2015/10/21/chartex" xmlns:cx3="http://schemas.microsoft.com/office/drawing/2016/5/9/chartex" xmlns:cx4="http://schemas.microsoft.com/office/drawing/2016/5/10/chartex" xmlns:cx5="http://schemas.microsoft.com/office/drawing/2016/5/11/chartex" xmlns:cx6="http://schemas.microsoft.com/office/drawing/2016/5/12/chartex" xmlns:cx7="http://schemas.microsoft.com/office/drawing/2016/5/13/chartex" xmlns:cx8="http://schemas.microsoft.com/office/drawing/2016/5/14/chartex" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" xmlns:aink="http://schemas.microsoft.com/office/drawing/2016/ink" xmlns:am3d="http://schemas.microsoft.com/office/drawing/2017/model3d" xmlns:o="urn:schemas-microsoft-com:office:office" xmlns:oel="http://schemas.microsoft.com/office/2019/extlst" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" xmlns:m="http://schemas.openxmlformats.org/officeDocument/2006/math" xmlns:v="urn:schemas-microsoft-com:vml" xmlns:wp14="http://schemas.microsoft.com/office/word/2010/wordprocessingDrawing" xmlns:wp="http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing" xmlns:w10="urn:schemas-microsoft-com:office:word" xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main" xmlns:w14="http://schemas.microsoft.com/office/word/2010/wordml" xmlns:w15="http://schemas.microsoft.com/office/word/2012/wordml" xmlns:w16cex="http://schemas.microsoft.com/office/word/2018/wordml/cex" xmlns:w16cid="http://schemas.microsoft.com/office/word/2016/wordml/cid" xmlns:w16="http://schemas.microsoft.com/office/word/2018/wordml" xmlns:w16du="http://schemas.microsoft.com/office/word/2023/wordml/word16du" xmlns:w16sdtdh="http://schemas.microsoft.com/office/word/2020/wordml/sdtdatahash" xmlns:w16sdtfl="http://schemas.microsoft.com/office/word/2024/wordml/sdtformatlock" xmlns:w16se="http://schemas.microsoft.com/office/word/2015/wordml/symex" xmlns:wpg="http://schemas.microsoft.com/office/word/2010/wordprocessingGroup" xmlns:wpi="http://schemas.microsoft.com/office/word/2010/wordprocessingInk" xmlns:wne="http://schemas.microsoft.com/office/word/2006/wordml" xmlns:wps="http://schemas.microsoft.com/office/word/2010/wordprocessingShape" mc:Ignorable="w14 w15 w16se w16cid w16 w16cex w16sdtdh w16sdtfl w16du wp14">
    </w16cid:commentsIds>
  • docx/scripts/templates/people.xml147 Ba839cafeb3e5upstream ↗
    <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
    <w15:people xmlns:w15="http://schemas.microsoft.com/office/word/2012/wordml">
    </w15:people>
  • docx/scripts/utilities.py13 KBd92dae611d44upstream ↗
    #!/usr/bin/env python3
    """
    Utilities for editing OOXML documents.
    
    This module provides XMLEditor, a tool for manipulating XML files with support for
    line-number-based node finding and DOM manipulation. Each element is automatically
    annotated with its original line and column position during parsing.
    
    Example usage:
        editor = XMLEditor("document.xml")
    
        # Find node by line number or range
        elem = editor.get_node(tag="w:r", line_number=519)
        elem = editor.get_node(tag="w:p", line_number=range(100, 200))
    
        # Find node by text content
        elem = editor.get_node(tag="w:p", contains="specific text")
    
        # Find node by attributes
        elem = editor.get_node(tag="w:r", attrs={"w:id": "target"})
    
        # Combine filters
        elem = editor.get_node(tag="w:p", line_number=range(1, 50), contains="text")
    
        # Replace, insert, or manipulate
        new_elem = editor.replace_node(elem, "<w:r><w:t>new text</w:t></w:r>")
        editor.insert_after(new_elem, "<w:r><w:t>more</w:t></w:r>")
    
        # Save changes
        editor.save()
    """
    
    import html
    from pathlib import Path
    from typing import Optional, Union
    
    import defusedxml.minidom
    import defusedxml.sax
    
    
    class XMLEditor:
        """
        Editor for manipulating OOXML XML files with line-number-based node finding.
    
        This class parses XML files and tracks the original line and column position
        of each element. This enables finding nodes by their line number in the original
        file, which is useful when working with Read tool output.
    
        Attributes:
            xml_path: Path to the XML file being edited
            encoding: Detected encoding of the XML file ('ascii' or 'utf-8')
            dom: Parsed DOM tree with parse_position attributes on elements
        """
    
        def __init__(self, xml_path):
            """
            Initialize with path to XML file and parse with line number tracking.
    
            Args:
                xml_path: Path to XML file to edit (str or Path)
    
            Raises:
                ValueError: If the XML file does not exist
            """
            self.xml_path = Path(xml_path)
            if not self.xml_path.exists():
                raise ValueError(f"XML file not found: {xml_path}")
    
            with open(self.xml_path, "rb") as f:
                header = f.read(200).decode("utf-8", errors="ignore")
            self.encoding = "ascii" if 'encoding="ascii"' in header else "utf-8"
    
            parser = _create_line_tracking_parser()
            self.dom = defusedxml.minidom.parse(str(self.xml_path), parser)
    
        def get_node(
            self,
            tag: str,
            attrs: Optional[dict[str, str]] = None,
            line_number: Optional[Union[int, range]] = None,
            contains: Optional[str] = None,
        ):
            """
            Get a DOM element by tag and identifier.
    
            Finds an element by either its line number in the original file or by
            matching attribute values. Exactly one match must be found.
    
            Args:
                tag: The XML tag name (e.g., "w:del", "w:ins", "w:r")
                attrs: Dictionary of attribute name-value pairs to match (e.g., {"w:id": "1"})
                line_number: Line number (int) or line range (range) in original XML file (1-indexed)
                contains: Text string that must appear in any text node within the element.
                          Supports both entity notation (&#8220;) and Unicode characters (“).
    
            Returns:
                defusedxml.minidom.Element: The matching DOM element
    
            Raises:
                ValueError: If node not found or multiple matches found
    
            Example:
                elem = editor.get_node(tag="w:r", line_number=519)
                elem = editor.get_node(tag="w:r", line_number=range(100, 200))
                elem = editor.get_node(tag="w:del", attrs={"w:id": "1"})
                elem = editor.get_node(tag="w:p", attrs={"w14:paraId": "12345678"})
                elem = editor.get_node(tag="w:commentRangeStart", attrs={"w:id": "0"})
                elem = editor.get_node(tag="w:p", contains="specific text")
                elem = editor.get_node(tag="w:t", contains="&#8220;Agreement")  # Entity notation
                elem = editor.get_node(tag="w:t", contains="“Agreement")   # Unicode character
            """
            matches = []
            for elem in self.dom.getElementsByTagName(tag):
                # Check line_number filter
                if line_number is not None:
                    parse_pos = getattr(elem, "parse_position", (None,))
                    elem_line = parse_pos[0]
    
                    # Handle both single line number and range
                    if isinstance(line_number, range):
                        if elem_line not in line_number:
                            continue
                    else:
                        if elem_line != line_number:
                            continue
    
                # Check attrs filter
                if attrs is not None:
                    if not all(
                        elem.getAttribute(attr_name) == attr_value
                        for attr_name, attr_value in attrs.items()
                    ):
                        continue
    
                # Check contains filter
                if contains is not None:
                    elem_text = self._get_element_text(elem)
                    # Normalize the search string: convert HTML entities to Unicode characters
                    # This allows searching for both "&#8220;Rowan" and ""Rowan"
                    normalized_contains = html.unescape(contains)
                    if normalized_contains not in elem_text:
                        continue
    
                # If all applicable filters passed, this is a match
                matches.append(elem)
    
            if not matches:
                # Build descriptive error message
                filters = []
                if line_number is not None:
                    line_str = (
                        f"lines {line_number.start}-{line_number.stop - 1}"
                        if isinstance(line_number, range)
                        else f"line {line_number}"
                    )
                    filters.append(f"at {line_str}")
                if attrs is not None:
                    filters.append(f"with attributes {attrs}")
                if contains is not None:
                    filters.append(f"containing '{contains}'")
    
                filter_desc = " ".join(filters) if filters else ""
                base_msg = f"Node not found: <{tag}> {filter_desc}".strip()
    
                # Add helpful hint based on filters used
                if contains:
                    hint = "Text may be split across elements or use different wording."
                elif line_number:
                    hint = "Line numbers may have changed if document was modified."
                elif attrs:
                    hint = "Verify attribute values are correct."
                else:
                    hint = "Try adding filters (attrs, line_number, or contains)."
    
                raise ValueError(f"{base_msg}. {hint}")
            if len(matches) > 1:
                raise ValueError(
                    f"Multiple nodes found: <{tag}>. "
                    f"Add more filters (attrs, line_number, or contains) to narrow the search."
                )
            return matches[0]
    
        def _get_element_text(self, elem):
            """
            Recursively extract all text content from an element.
    
            Skips text nodes that contain only whitespace (spaces, tabs, newlines),
            which typically represent XML formatting rather than document content.
    
            Args:
                elem: defusedxml.minidom.Element to extract text from
    
            Returns:
                str: Concatenated text from all non-whitespace text nodes within the element
            """
            text_parts = []
            for node in elem.childNodes:
                if node.nodeType == node.TEXT_NODE:
                    # Skip whitespace-only text nodes (XML formatting)
                    if node.data.strip():
                        text_parts.append(node.data)
                elif node.nodeType == node.ELEMENT_NODE:
                    text_parts.append(self._get_element_text(node))
            return "".join(text_parts)
    
        def replace_node(self, elem, new_content):
            """
            Replace a DOM element with new XML content.
    
            Args:
                elem: defusedxml.minidom.Element to replace
                new_content: String containing XML to replace the node with
    
            Returns:
                List[defusedxml.minidom.Node]: All inserted nodes
    
            Example:
                new_nodes = editor.replace_node(old_elem, "<w:r><w:t>text</w:t></w:r>")
            """
            parent = elem.parentNode
            nodes = self._parse_fragment(new_content)
            for node in nodes:
                parent.insertBefore(node, elem)
            parent.removeChild(elem)
            return nodes
    
        def insert_after(self, elem, xml_content):
            """
            Insert XML content after a DOM element.
    
            Args:
                elem: defusedxml.minidom.Element to insert after
                xml_content: String containing XML to insert
    
            Returns:
                List[defusedxml.minidom.Node]: All inserted nodes
    
            Example:
                new_nodes = editor.insert_after(elem, "<w:r><w:t>text</w:t></w:r>")
            """
            parent = elem.parentNode
            next_sibling = elem.nextSibling
            nodes = self._parse_fragment(xml_content)
            for node in nodes:
                if next_sibling:
                    parent.insertBefore(node, next_sibling)
                else:
                    parent.appendChild(node)
            return nodes
    
        def insert_before(self, elem, xml_content):
            """
            Insert XML content before a DOM element.
    
            Args:
                elem: defusedxml.minidom.Element to insert before
                xml_content: String containing XML to insert
    
            Returns:
                List[defusedxml.minidom.Node]: All inserted nodes
    
            Example:
                new_nodes = editor.insert_before(elem, "<w:r><w:t>text</w:t></w:r>")
            """
            parent = elem.parentNode
            nodes = self._parse_fragment(xml_content)
            for node in nodes:
                parent.insertBefore(node, elem)
            return nodes
    
        def append_to(self, elem, xml_content):
            """
            Append XML content as a child of a DOM element.
    
            Args:
                elem: defusedxml.minidom.Element to append to
                xml_content: String containing XML to append
    
            Returns:
                List[defusedxml.minidom.Node]: All inserted nodes
    
            Example:
                new_nodes = editor.append_to(elem, "<w:r><w:t>text</w:t></w:r>")
            """
            nodes = self._parse_fragment(xml_content)
            for node in nodes:
                elem.appendChild(node)
            return nodes
    
        def get_next_rid(self):
            """Get the next available rId for relationships files."""
            max_id = 0
            for rel_elem in self.dom.getElementsByTagName("Relationship"):
                rel_id = rel_elem.getAttribute("Id")
                if rel_id.startswith("rId"):
                    try:
                        max_id = max(max_id, int(rel_id[3:]))
                    except ValueError:
                        pass
            return f"rId{max_id + 1}"
    
        def save(self):
            """
            Save the edited XML back to the file.
    
            Serializes the DOM tree and writes it back to the original file path,
            preserving the original encoding (ascii or utf-8).
            """
            content = self.dom.toxml(encoding=self.encoding)
            self.xml_path.write_bytes(content)
    
        def _parse_fragment(self, xml_content):
            """
            Parse XML fragment and return list of imported nodes.
    
            Args:
                xml_content: String containing XML fragment
    
            Returns:
                List of defusedxml.minidom.Node objects imported into this document
    
            Raises:
                AssertionError: If fragment contains no element nodes
            """
            # Extract namespace declarations from the root document element
            root_elem = self.dom.documentElement
            namespaces = []
            if root_elem and root_elem.attributes:
                for i in range(root_elem.attributes.length):
                    attr = root_elem.attributes.item(i)
                    if attr.name.startswith("xmlns"):  # type: ignore
                        namespaces.append(f'{attr.name}="{attr.value}"')  # type: ignore
    
            ns_decl = " ".join(namespaces)
            wrapper = f"<root {ns_decl}>{xml_content}</root>"
            fragment_doc = defusedxml.minidom.parseString(wrapper)
            nodes = [
                self.dom.importNode(child, deep=True)
                for child in fragment_doc.documentElement.childNodes  # type: ignore
            ]
            elements = [n for n in nodes if n.nodeType == n.ELEMENT_NODE]
            assert elements, "Fragment must contain at least one element"
            return nodes
    
    
    def _create_line_tracking_parser():
        """
        Create a SAX parser that tracks line and column numbers for each element.
    
        Monkey patches the SAX content handler to store the current line and column
        position from the underlying expat parser onto each element as a parse_position
        attribute (line, column) tuple.
    
        Returns:
            defusedxml.sax.xmlreader.XMLReader: Configured SAX parser
        """
    
        def set_content_handler(dom_handler):
            def startElementNS(name, tagName, attrs):
                orig_start_cb(name, tagName, attrs)
                cur_elem = dom_handler.elementStack[-1]
                cur_elem.parse_position = (
                    parser._parser.CurrentLineNumber,  # type: ignore
                    parser._parser.CurrentColumnNumber,  # type: ignore
                )
    
            orig_start_cb = dom_handler.startElementNS
            dom_handler.startElementNS = startElementNS
            orig_set_content_handler(dom_handler)
    
        parser = defusedxml.sax.make_parser()
        orig_set_content_handler = parser.setContentHandler
        parser.setContentHandler = set_content_handler  # type: ignore
        return parser
    
  • docx/docx-js.md10 KBc35aba4ebef1upstream ↗
    # Creating Word documents with docx-js
    
    docx-js (the `docx` npm package, v9) builds a `.docx` from JavaScript objects. This file covers the parts of its API that produce broken or surprising output when guessed at.
    
    ## Running a script
    
    Write CommonJS (`require`), and put `await` inside an async function, since a `.js` file run by Node is not a module and rejects top-level `await`. Point Node at the skill's packages, and run from the user's working directory so output lands there:
    
    ```bash
    NODE_PATH=<skill>/node_modules node build.js
    ```
    
    If `<skill>/node_modules` is missing, run `npm install` in `<skill>` once.
    
    ## A complete document
    
    Every pattern below appears in this example, which validates cleanly and renders as intended. Start from it and remove what you don't need.
    
    ```javascript
    const fs = require("fs");
    const {
      Document, Packer, Paragraph, TextRun, HeadingLevel, AlignmentType, LevelFormat,
      Table, TableRow, TableCell, WidthType, BorderStyle, ShadingType, VerticalAlign,
      ImageRun, ExternalHyperlink, InternalHyperlink, Bookmark, TableOfContents,
      Header, Footer, PageNumber, PageBreak, FootnoteReferenceRun,
    } = require("docx");
    
    const LETTER = { width: 12240, height: 15840 };     // 8.5 x 11 in, in DXA
    const MARGIN = 1440;                                 // 1 in
    const CONTENT = LETTER.width - 2 * MARGIN;           // 9360 DXA of usable width
    
    const border = { style: BorderStyle.SINGLE, size: 4, color: "BFBFBF" };
    const cell = (text, width, opts = {}) => new TableCell({
      width: { size: width, type: WidthType.DXA },
      borders: { top: border, bottom: border, left: border, right: border },
      shading: opts.fill ? { fill: opts.fill, type: ShadingType.CLEAR, color: "auto" } : undefined,
      verticalAlign: VerticalAlign.CENTER,
      children: [new Paragraph({ children: [new TextRun({ text, bold: opts.bold })] })],
    });
    
    async function main() {
      const doc = new Document({
        features: { updateFields: true },  // Word refreshes the TOC and page fields on open
        styles: {
          default: {
            document: { run: { font: "Arial", size: 22 } },  // 11 pt body
            title: { run: { font: "Arial", size: 48, bold: true } },
            heading1: { run: { font: "Arial", size: 32, bold: true }, paragraph: { spacing: { before: 360, after: 120 } } },
            heading2: { run: { font: "Arial", size: 26, bold: true }, paragraph: { spacing: { before: 240, after: 80 } } },
          },
          paragraphStyles: [
            { id: "Note", name: "Note", basedOn: "Normal", run: { italics: true, color: "595959" } },
          ],
        },
        numbering: {
          config: [
            { reference: "bullets", levels: [{ level: 0, format: LevelFormat.BULLET, text: "•", alignment: AlignmentType.LEFT,
                style: { paragraph: { indent: { left: 720, hanging: 360 } } } }] },
            { reference: "steps", levels: [{ level: 0, format: LevelFormat.DECIMAL, text: "%1.", alignment: AlignmentType.LEFT,
                style: { paragraph: { indent: { left: 720, hanging: 360 } } } }] },
          ],
        },
        footnotes: {
          1: { children: [new Paragraph("Source: internal finance report, Q3 2026.")] },
        },
        sections: [{
          properties: { page: { size: LETTER, margin: { top: MARGIN, right: MARGIN, bottom: MARGIN, left: MARGIN } } },
          headers: { default: new Header({ children: [new Paragraph({ alignment: AlignmentType.RIGHT, children: [new TextRun("Quarterly review")] })] }) },
          footers: { default: new Footer({ children: [new Paragraph({ alignment: AlignmentType.CENTER,
            children: [new TextRun({ children: ["Page ", PageNumber.CURRENT, " of ", PageNumber.TOTAL_PAGES] })] })] }) },
          children: [
            new Paragraph({ heading: HeadingLevel.TITLE, children: [new TextRun("Quarterly Review")] }),
            new TableOfContents("Contents", { hyperlink: true, headingStyleRange: "1-2" }),
            new Paragraph({ children: [new PageBreak()] }),
            new Paragraph({ heading: HeadingLevel.HEADING_1, children: [new Bookmark({ id: "results", children: [new TextRun("Results")] })] }),
            new Paragraph({ children: [
              new TextRun("Revenue grew 18%"), new FootnoteReferenceRun(1), new TextRun(". See "),
              new ExternalHyperlink({ link: "https://example.com", children: [new TextRun({ text: "the dashboard", style: "Hyperlink" })] }),
              new TextRun("."),
            ] }),
            new Paragraph({ numbering: { reference: "bullets", level: 0 }, children: [new TextRun("Enterprise up 24%")] }),
            new Paragraph({ numbering: { reference: "bullets", level: 0 }, children: [new TextRun("Consumer flat")] }),
            new Paragraph({ heading: HeadingLevel.HEADING_2, children: [new TextRun("By region")] }),
            new Table({
              width: { size: CONTENT, type: WidthType.DXA },
              columnWidths: [CONTENT / 2, CONTENT / 2],
              rows: [
                new TableRow({ tableHeader: true, children: [cell("Region", CONTENT / 2, { bold: true, fill: "D9E2F3" }), cell("Growth", CONTENT / 2, { bold: true, fill: "D9E2F3" })] }),
                new TableRow({ children: [cell("EMEA", CONTENT / 2), cell("12%", CONTENT / 2)] }),
              ],
            }),
            new Paragraph({ alignment: AlignmentType.CENTER, children: [
              new ImageRun({ type: "png", data: fs.readFileSync("chart.png"), transformation: { width: 400, height: 200 },
                altText: { name: "chart", description: "Revenue by quarter" } }),
            ] }),
            new Paragraph({ children: [
              new ImageRun({ type: "svg", data: fs.readFileSync("logo.svg"), transformation: { width: 100, height: 50 },
                fallback: { type: "png", data: fs.readFileSync("chart.png") } }),
            ] }),
            new Paragraph({ numbering: { reference: "steps", level: 0 }, children: [new TextRun("Review the figures")] }),
            new Paragraph({ numbering: { reference: "steps", level: 0 }, children: [new TextRun("Approve the budget")] }),
            new Paragraph({ style: "Note", children: [
              new TextRun("Back to "), new InternalHyperlink({ anchor: "results", children: [new TextRun({ text: "Results", style: "Hyperlink" })] }),
            ] }),
          ],
        }],
      });
      fs.writeFileSync("report.docx", await Packer.toBuffer(doc));
    }
    
    main();
    ```
    
    ## Page size
    
    docx-js defaults to **A4** (11906 × 16838 DXA). For US documents, set Letter explicitly as above. Every width depends on this choice, with 1440 DXA = 1 inch:
    
    | Page, 1" margins | `size` | Usable width | Two columns | Three columns |
    |---|---|---|---|---|
    | Letter | `{ width: 12240, height: 15840 }` | 9360 | `[4680, 4680]` | `[3120, 3120, 3120]` |
    | A4 | `{ width: 11906, height: 16838 }` | 9026 | `[4513, 4513]` | `[3009, 3009, 3008]` |
    
    For landscape, add `orientation: PageOrientation.LANDSCAPE` to `size` and keep the portrait numbers; docx-js swaps them. `TabStopPosition.MAX` is 9026, the A4 right margin, so on Letter use 9360 for a right-aligned tab.
    
    ## Styles
    
    - Restyle built-in styles through `styles.default`: `document`, `title`, `heading1` … `heading6`, `listParagraph`, `hyperlink`. Defining a `paragraphStyles` entry with id `Heading1` writes a second Heading1 style next to the built-in one, and which one Word applies is undefined.
    - Use `paragraphStyles` and `characterStyles` for your own styles, with your own ids, and apply them with `style: "Note"`.
    - Headings must use `heading: HeadingLevel.HEADING_n` with no custom `style`, or the table of contents will not find them.
    - Sizes are in half-points: `size: 22` is 11 pt.
    
    ## Text
    
    - One `Paragraph` per line. `\n` inside a `TextRun` does not make a line break.
    - Run options: `bold`, `italics`, `underline: { type: UnderlineType.SINGLE }`, `strike`, `superScript`, `subScript`, `smallCaps`, `color: "C00000"`, `font`, `size`.
    - `highlight: "yellow"` also writes a `w:highlightCs` element that fails schema validation. Pass `highlightComplexScript: false` alongside it.
    - Type symbols as plain characters in a `TextRun` ("✓ ✗ © ™"). `SymbolRun` codes such as `F0FC` only mean a check mark in the Wingdings font.
    
    ## Lists
    
    Use a numbering config with `LevelFormat.BULLET` or `LevelFormat.DECIMAL`, never a typed "•", which looks like a list but does not behave like one. Paragraphs sharing a `reference` continue one sequence, and a different reference restarts at 1. So give each separately numbered list its own reference.
    
    ## Tables
    
    - Set `columnWidths` on the table and the same `width` (type `WidthType.DXA`) on every cell. Make the widths add up to the usable width of the page size you chose.
    - Shade cells with `type: ShadingType.CLEAR`. `ShadingType.SOLID` paints the cell black in Word.
    - Put borders on cells, not on the table. Every cell needs at least one `Paragraph`.
    
    ## Links, bookmarks, table of contents
    
    - **Bookmarks:** create the target with `new Bookmark({ id, children })` inside a paragraph, and point at it with `new InternalHyperlink({ anchor: id, … })`. A `bookmark:` option on `Paragraph` is silently ignored.
    - **Table of contents:** `TableOfContents` inserts a field that Word fills in when it updates fields. `features: { updateFields: true }` makes Word offer to do that on open, with a prompt that the document "contains fields that may refer to other files". No other file is involved, so tell the user that accepting is safe, and leave the setting out of documents without a table of contents. LibreOffice and `render.py` show the table empty, which is expected.
    
    ## Images
    
    - `type` is required (`png`, `jpg`, `gif`, `bmp`, `svg`).
    - `transformation` is in pixels. Keep the aspect ratio of the source, and keep the width within the page.
    - An `svg` image also needs a raster `fallback: { type: "png", data }`, or docx-js throws "Cannot read properties of undefined (reading 'type')".
    - `altText` is optional. When you give it, include `name`, or the drawing fails schema validation.
    
    ## Footnotes
    
    Define the notes in `footnotes` on the `Document`, keyed by number, and reference them with `new FootnoteReferenceRun(n)`. There is no `Footnote` class to import.
    
    ## Page breaks and sections
    
    - **Page breaks:** `new PageBreak()` only works inside a paragraph's children. For a heading that should start a new page, use `pageBreakBefore: true` on the paragraph.
    - **Sections:** each entry in `sections` starts a new page, with its own size, orientation, margins, headers and footers.
    - **Headers and footers:** they take paragraphs. Page numbers go in a run's children, `PageNumber.CURRENT` and `PageNumber.TOTAL_PAGES`, mixed with plain strings as in the example.
    
  • docx/ooxml.md14 KBde192aec8431upstream ↗
    # Editing Word documents: the Document library and OOXML
    
    This file covers editing an unpacked `.docx`: the Python `Document` library for tracked changes and comments, and the XML patterns underneath it.
    
    ## Running a script with the library
    
    Your script puts the skill directory first on `sys.path`, so the import cannot collide with a `scripts` package in the user's project. It declares its dependencies in a PEP 723 header and runs with `uv run`:
    
    ```python
    # /// script
    # requires-python = ">=3.12"
    # dependencies = ["defusedxml>=0.7", "lxml>=5"]
    # ///
    import sys
    sys.path.insert(0, "<skill>")  # absolute path of the docx skill directory
    from scripts.document import Document, DocxXMLEditor
    
    doc = Document("unpacked", author="Claude", initials="C")
    ```
    
    ```bash
    uv run edit.py
    ```
    
    `Document` options:
    
    - `author` and `initials`: name the reviewer on every change and comment. They default to "Claude"/"C"; use the name the user wants reviewers to see.
    - `rsid`: set it to the value `unpack.py` printed, so all edits in the session share one revision ID. If omitted, one is generated.
    - `track_revisions=True`: turns on Track Changes in the file, so the user's own later edits are tracked too.
    
    The library edits a temporary copy of the unpacked directory. `doc.save()` validates the result and copies it back (or to `doc.save("other-dir")`).
    
    ## Tracked changes
    
    ### Replacing text: `tracked_replace`
    
    Use this for almost every edit. It finds the text in a paragraph even when Word has split it across several runs. Formatting changes, proofing marks, and the script boundaries in Chinese or Japanese text all split runs. It then marks only the words that differ:
    
    ```python
    body = doc["word/document.xml"]
    body.tracked_replace("within 30 days", "within 45 days")      # marks 30 -> 45 only
    body.tracked_replace("期限为30天", "期限为45天")                 # CJK is compared per character
    body.tracked_replace("Acme Corp", "Acme Inc.", replace_all=True)
    body.tracked_replace("the Seller", "the Vendor", scope=body.get_node(tag="w:p", contains="Section 4.2"))
    body.tracked_replace(", without limitation,", "")              # deletion
    ```
    
    - `old` must lie within one paragraph and match its visible text exactly. Deleted text is not searched; tabs match `"\t"` and line breaks `"\n"`.
    - If `old` occurs more than once, it raises and shows where. Narrow the search with `scope=` (any element: a paragraph, a table, a cell), or pass `replace_all=True`.
    - Unchanged text keeps its original runs, formatting and RSIDs. Inserted text takes the formatting of the text it replaces.
    - It returns the new `w:del`/`w:ins` elements, ready for `doc.add_comment(start=..., end=...)`.
    - Text inside another author's insertion can be deleted, which nests your deletion inside their insertion. It can be replaced only when the change reaches the start or end of that insertion. For a change in its middle, reject the whole insertion with `revert_insertion()` and insert the corrected text.
    
    ### Deleting whole runs or paragraphs
    
    ```python
    body.suggest_deletion(body.get_node(tag="w:r", contains="text to delete"))
    body.suggest_deletion(body.get_node(tag="w:p", contains="paragraph to delete"))
    ```
    
    Deleting a paragraph also marks its paragraph mark deleted. Accepting the change then removes the paragraph instead of leaving an empty line. The last paragraph of the body, a cell or a text box keeps its mark, as in Word.
    
    ### Inserting paragraphs
    
    ```python
    target = body.get_node(tag="w:p", contains="existing list item")
    pPr = tags[0].toxml() if (tags := target.getElementsByTagName("w:pPr")) else ""
    body.insert_after(target, DocxXMLEditor.suggest_paragraph(f"<w:p>{pPr}<w:r><w:t>New item</w:t></w:r></w:p>"))
    ```
    
    `suggest_paragraph` wraps the runs in `<w:ins>` and marks the paragraph mark inserted. Reusing the neighbour's `w:pPr` keeps the list numbering and style.
    
    ### Other authors' changes
    
    ```python
    ins = body.get_node(tag="w:ins", attrs={"w:id": "5"})
    body.revert_insertion(ins)        # reject their insertion: nests a <w:del> inside it
    dele = body.get_node(tag="w:del", attrs={"w:id": "3"})
    body.revert_deletion(dele)        # reject their deletion: re-inserts the text after it
    ```
    
    Both also accept a paragraph or other container, which handles every insertion or deletion inside it.
    
    ### Accepting or rejecting everything
    
    ```python
    doc.accept_all_changes()   # or doc.reject_all_changes()
    ```
    
    These cover the body, headers, footers, footnotes, endnotes and comments, like Word's Accept All and Reject All. That includes paragraph marks, moves, table rows and formatting changes. Call them before your own edits. Edits made earlier must already be tracked, and later ones are checked against the resolved document.
    
    ### Writing the XML yourself
    
    When no method fits, replace a node with explicit `<w:del>`/`<w:ins>` markup. The library fills in `w:id`, `w:author`, `w:date` and RSIDs on new elements:
    
    ```python
    node = body.get_node(tag="w:r", contains="The report is monthly")
    rpr = tags[0].toxml() if (tags := node.getElementsByTagName("w:rPr")) else ""
    body.replace_node(node,
        f'<w:r>{rpr}<w:t xml:space="preserve">The report is </w:t></w:r>'
        f'<w:del><w:r>{rpr}<w:delText>monthly</w:delText></w:r></w:del>'
        f'<w:ins><w:r>{rpr}<w:t>quarterly</w:t></w:r></w:ins>')
    ```
    
    The rules every tracked change must follow:
    
    - `<w:ins>` and `<w:del>` wrap whole `<w:r>` elements at paragraph level, never the inside of a run.
    - Deleted text goes in `<w:delText>`, not `<w:t>`.
    - Mark only what changes. Keep unchanged text in its original run, with its attributes.
    - Never edit inside another author's `<w:ins>` or `<w:del>` directly. To remove part of their insertion, nest your `<w:del>` inside it. To restore their deletion, add your `<w:ins>` after it.
    
    ```xml
    <!-- Rejecting part of Jane's insertion, then adding a replacement after it -->
    <w:ins w:id="16" w:author="Jane Smith" w:date="2026-01-15T10:00:00Z">
      <w:r><w:t xml:space="preserve">in silence, </w:t></w:r>
      <w:del w:author="Claude"><w:r><w:delText>safe and sound</w:delText></w:r></w:del>
    </w:ins>
    <w:ins w:author="Claude"><w:r><w:t>soft and unbound</w:t></w:r></w:ins>
    
    <!-- Restoring Jane's deletion -->
    <w:del w:id="50" w:author="Jane Smith" w:date="2026-01-15T10:00:00Z">
      <w:r><w:delText>within 30 days</w:delText></w:r>
    </w:del>
    <w:ins w:author="Claude"><w:r><w:t>within 30 days</w:t></w:r></w:ins>
    ```
    
    ### What `save()` checks
    
    `doc.save()` raises if the result is invalid. It checks two things:
    
    - **Schema:** the XML must match the OOXML schema, ignoring problems the original file already had.
    - **Tracking:** rejecting every tracked change must give back the original text, so an edit made without tracking shows up as a difference, whoever the author. Other authors' insertions must also keep their text.
    
    The error prints the differing text. The usual causes are editing text directly instead of through `<w:ins>`/`<w:del>`, and editing inside someone else's change. For a document of your own that needs no review, `save(require_tracking=False)` keeps the schema check and drops the tracking one. `save(validate=False)` skips both; use it only to inspect a broken state, never for a deliverable.
    
    ## Comments
    
    ```python
    para = body.get_node(tag="w:p", contains="paragraph text")
    cid = doc.add_comment(start=para, end=para, text="Please confirm this date.")
    doc.reply_to_comment(parent_comment_id=cid, text="Confirmed with finance.")
    
    changes = body.tracked_replace("30 days", "45 days")
    doc.add_comment(start=changes[0], end=changes[-1], text="Extended per the March amendment.")
    ```
    
    `start` and `end` can be paragraphs, runs or tracked-change elements. The library creates or updates `comments.xml` and its companion parts, and their relationships and content types. That works on documents from Word, LibreOffice, docx-js and pandoc alike.
    
    ## Finding nodes
    
    ```python
    body.get_node(tag="w:p", contains="specific text")             # text within the element
    body.get_node(tag="w:del", attrs={"w:id": "1"})                 # attribute values
    body.get_node(tag="w:p", line_number=42)                        # line where the tag opens
    body.get_node(tag="w:r", contains="Section", line_number=range(2400, 2500))
    ```
    
    `get_node` must match exactly one element. `contains` sees the text of a single element, so text split across runs is found with `tag="w:p"`, or replaced directly with `tracked_replace`. Line numbers refer to the file as it was unpacked, so grep `word/document.xml` again after every saved edit.
    
    `doc["word/comments.xml"]`, `doc["word/header1.xml"]` and so on give editors for other parts. Each editor's `.dom` is a minidom document for anything the methods don't cover.
    
    ## Inserting an image
    
    ```python
    # /// script
    # requires-python = ">=3.12"
    # dependencies = ["defusedxml>=0.7", "lxml>=5", "Pillow>=10"]
    # ///
    import shutil, sys
    sys.path.insert(0, "<skill>")
    from PIL import Image
    from scripts.document import Document, DocxXMLEditor
    
    doc = Document("unpacked")
    body = doc["word/document.xml"]
    
    # Copy the image into the working copy the library edits, under an unused name
    media = doc.unpacked_path / "word" / "media"
    media.mkdir(exist_ok=True)
    n = 1
    while (media / f"image{n}.png").exists():
        n += 1
    shutil.copy("chart.png", media / f"image{n}.png")
    
    # Full usable width (6.5 in on Letter with 1 in margins), keeping the aspect ratio
    w, h = Image.open("chart.png").size
    cx = int(6.5 * 914400)
    cy = cx * h // w
    
    rels = doc["word/_rels/document.xml.rels"]
    rid = rels.get_next_rid()
    rels.append_to(rels.dom.documentElement,
        f'<Relationship Id="{rid}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/image" Target="media/image{n}.png"/>')
    types = doc["[Content_Types].xml"]
    if not any(d.getAttribute("Extension").lower() == "png" for d in types.dom.getElementsByTagName("Default")):
        types.append_to(types.dom.documentElement, '<Default Extension="png" ContentType="image/png"/>')
    
    # Drawing ids must be unique across the document
    pic_id = 1 + max((int(e.getAttribute("id")) for e in body.dom.getElementsByTagName("wp:docPr")), default=0)
    
    anchor = body.get_node(tag="w:p", contains="Second paragraph")
    body.insert_after(anchor, DocxXMLEditor.suggest_paragraph(f'''<w:p><w:r><w:drawing>
      <wp:inline distT="0" distB="0" distL="0" distR="0">
        <wp:extent cx="{cx}" cy="{cy}"/>
        <wp:docPr id="{pic_id}" name="Picture {pic_id}"/>
        <a:graphic><a:graphicData uri="http://schemas.openxmlformats.org/drawingml/2006/picture">
          <pic:pic>
            <pic:nvPicPr><pic:cNvPr id="{pic_id}" name="image{n}.png"/><pic:cNvPicPr/></pic:nvPicPr>
            <pic:blipFill><a:blip r:embed="{rid}"/><a:stretch><a:fillRect/></a:stretch></pic:blipFill>
            <pic:spPr><a:xfrm><a:off x="0" y="0"/><a:ext cx="{cx}" cy="{cy}"/></a:xfrm><a:prstGeom prst="rect"><a:avLst/></a:prstGeom></pic:spPr>
          </pic:pic>
        </a:graphicData></a:graphic>
      </wp:inline>
    </w:drawing></w:r></w:p>'''))
    doc.save()
    ```
    
    `suggest_paragraph` makes the insertion a tracked change. Drop it to insert the image silently, if the user doesn't want it reviewed. On A4 with 1-inch margins, the usable width is 6.27 inches.
    
    ## XML reference
    
    ### Schema rules that bite
    
    - **`<w:pPr>`:** children follow a fixed order, starting `pStyle`, `keepNext`, `keepLines`, `pageBreakBefore`, `numPr`, … `spacing`, `ind`, … `jc`, … and ending `rPr`, `sectPr`, `pPrChange`.
    - **Whitespace:** a `<w:t>` whose text starts or ends with a space needs `xml:space="preserve"`, or the space is dropped.
    - **Text encoding:** `unpack.py` writes UTF-8, so curly quotes, dashes and CJK text can be typed literally. Entities such as `&#8220;` (“) also work. In `contains=` searches, both forms find the same text.
    - **Settings:** turn on Track Changes with `Document(..., track_revisions=True)`, which puts `<w:trackRevisions/>` at its schema position in `settings.xml`: after `w:proofState`, `w:attachedTemplate`, `w:documentType`, `w:mailMerge` and `w:revisionView`, whichever are present.
    - **IDs and RSIDs:** RSIDs are 8 hex digits. Tracked-change `w:id` values must be unique; the library assigns them.
    
    ### Paragraphs and runs
    
    ```xml
    <w:p>
      <w:pPr><w:pStyle w:val="Heading2"/><w:jc w:val="center"/></w:pPr>
      <w:r><w:rPr><w:b/><w:bCs/></w:rPr><w:t>Bold heading text</w:t></w:r>
    </w:p>
    <!-- run formatting: <w:i/> italic, <w:u w:val="single"/> underline,
         <w:highlight w:val="yellow"/>, <w:rFonts w:ascii="Courier New" w:hAnsi="Courier New"/> -->
    <w:p><w:r><w:br w:type="page"/></w:r></w:p>   <!-- page break -->
    ```
    
    ### Lists
    
    ```xml
    <w:p>
      <w:pPr>
        <w:pStyle w:val="ListParagraph"/>
        <w:numPr><w:ilvl w:val="0"/><w:numId w:val="1"/></w:numPr>
      </w:pPr>
      <w:r><w:t>First item</w:t></w:r>
    </w:p>
    ```
    
    `w:ilvl` sets the nesting level. A different `w:numId`, defined in `numbering.xml`, starts a separate list. Copy the `w:pPr` of an existing item to continue its list.
    
    ### Tables
    
    ```xml
    <w:tbl>
      <w:tblPr><w:tblStyle w:val="TableGrid"/><w:tblW w:w="0" w:type="auto"/></w:tblPr>
      <w:tblGrid><w:gridCol w:w="4680"/><w:gridCol w:w="4680"/></w:tblGrid>
      <w:tr>
        <w:tc><w:tcPr><w:tcW w:w="4680" w:type="dxa"/></w:tcPr><w:p><w:r><w:t>Cell 1</w:t></w:r></w:p></w:tc>
        <w:tc><w:tcPr><w:tcW w:w="4680" w:type="dxa"/></w:tcPr><w:p><w:r><w:t>Cell 2</w:t></w:r></w:p></w:tc>
      </w:tr>
    </w:tbl>
    ```
    
    ### Hyperlinks and bookmarks
    
    ```xml
    <w:hyperlink r:id="rId5"><w:r><w:rPr><w:rStyle w:val="Hyperlink"/></w:rPr><w:t>External link</w:t></w:r></w:hyperlink>
    <w:hyperlink w:anchor="myBookmark"><w:r><w:rPr><w:rStyle w:val="Hyperlink"/></w:rPr><w:t>Internal link</w:t></w:r></w:hyperlink>
    <w:bookmarkStart w:id="0" w:name="myBookmark"/><w:r><w:t>Target</w:t></w:r><w:bookmarkEnd w:id="0"/>
    ```
    
    - **External links:** these need a relationship in `word/_rels/document.xml.rels`: `<Relationship Id="rId5" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink" Target="https://example.com/" TargetMode="External"/>`.
    - **The Hyperlink style:** links look like plain text unless `styles.xml` defines it:
    
    ```xml
    <w:style w:type="character" w:styleId="Hyperlink">
      <w:name w:val="Hyperlink"/><w:basedOn w:val="DefaultParagraphFont"/><w:uiPriority w:val="99"/><w:unhideWhenUsed/>
      <w:rPr><w:color w:val="467886" w:themeColor="hyperlink"/><w:u w:val="single"/></w:rPr>
    </w:style>
    ```
    
    ### Parts to update when adding content
    
    - `word/_rels/document.xml.rels`: a `Relationship` for each new part, image or external link.
    - `[Content_Types].xml`: a `Default` per file extension (`png`, `jpeg`), and an `Override` per new XML part. Check before adding, since a duplicate entry corrupts the package.
    
  • docx/ooxml/schemas/ecma/fourth-edition/opc-contentTypes.xsd1.9 KBa6de9d2733d3upstream ↗
    <?xml version="1.0" encoding="UTF-8" standalone="no"?>
    <xs:schema xmlns="http://schemas.openxmlformats.org/package/2006/content-types"
      xmlns:xs="http://www.w3.org/2001/XMLSchema"
      targetNamespace="http://schemas.openxmlformats.org/package/2006/content-types"
      elementFormDefault="qualified" attributeFormDefault="unqualified" blockDefault="#all">
    
      <xs:element name="Types" type="CT_Types"/>
      <xs:element name="Default" type="CT_Default"/>
      <xs:element name="Override" type="CT_Override"/>
    
      <xs:complexType name="CT_Types">
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="Default"/>
          <xs:element ref="Override"/>
        </xs:choice>
      </xs:complexType>
    
      <xs:complexType name="CT_Default">
        <xs:attribute name="Extension" type="ST_Extension" use="required"/>
        <xs:attribute name="ContentType" type="ST_ContentType" use="required"/>
      </xs:complexType>
    
      <xs:complexType name="CT_Override">
        <xs:attribute name="ContentType" type="ST_ContentType" use="required"/>
        <xs:attribute name="PartName" type="xs:anyURI" use="required"/>
      </xs:complexType>
    
      <xs:simpleType name="ST_ContentType">
        <xs:restriction base="xs:string">
          <xs:pattern
            value="(((([\p{IsBasicLatin}-[\p{Cc}&#127;\(\)&lt;&gt;@,;:\\&quot;/\[\]\?=\{\}\s\t]])+))/((([\p{IsBasicLatin}-[\p{Cc}&#127;\(\)&lt;&gt;@,;:\\&quot;/\[\]\?=\{\}\s\t]])+))((\s+)*;(\s+)*(((([\p{IsBasicLatin}-[\p{Cc}&#127;\(\)&lt;&gt;@,;:\\&quot;/\[\]\?=\{\}\s\t]])+))=((([\p{IsBasicLatin}-[\p{Cc}&#127;\(\)&lt;&gt;@,;:\\&quot;/\[\]\?=\{\}\s\t]])+)|(&quot;(([\p{IsLatin-1Supplement}\p{IsBasicLatin}-[\p{Cc}&#127;&quot;\n\r]]|(\s+))|(\\[\p{IsBasicLatin}]))*&quot;))))*)"
          />
        </xs:restriction>
      </xs:simpleType>
    
      <xs:simpleType name="ST_Extension">
        <xs:restriction base="xs:string">
          <xs:pattern
            value="([!$&amp;'\(\)\*\+,:=]|(%[0-9a-fA-F][0-9a-fA-F])|[:@]|[a-zA-Z0-9\-_~])+"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:schema>
    
  • docx/ooxml/schemas/ecma/fourth-edition/opc-coreProperties.xsd2.5 KB10e978b661fcupstream ↗
    <?xml version="1.0" encoding="UTF-8"?>
    <xs:schema targetNamespace="http://schemas.openxmlformats.org/package/2006/metadata/core-properties"
      xmlns="http://schemas.openxmlformats.org/package/2006/metadata/core-properties"
      xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:dc="http://purl.org/dc/elements/1.1/"
      xmlns:dcterms="http://purl.org/dc/terms/" elementFormDefault="qualified" blockDefault="#all">
    
      <xs:import namespace="http://purl.org/dc/elements/1.1/"
        schemaLocation="http://dublincore.org/schemas/xmls/qdc/2003/04/02/dc.xsd"/>
      <xs:import namespace="http://purl.org/dc/terms/"
        schemaLocation="http://dublincore.org/schemas/xmls/qdc/2003/04/02/dcterms.xsd"/>
      <xs:import id="xml" namespace="http://www.w3.org/XML/1998/namespace"/>
    
      <xs:element name="coreProperties" type="CT_CoreProperties"/>
    
      <xs:complexType name="CT_CoreProperties">
        <xs:all>
          <xs:element name="category" minOccurs="0" maxOccurs="1" type="xs:string"/>
          <xs:element name="contentStatus" minOccurs="0" maxOccurs="1" type="xs:string"/>
          <xs:element ref="dcterms:created" minOccurs="0" maxOccurs="1"/>
          <xs:element ref="dc:creator" minOccurs="0" maxOccurs="1"/>
          <xs:element ref="dc:description" minOccurs="0" maxOccurs="1"/>
          <xs:element ref="dc:identifier" minOccurs="0" maxOccurs="1"/>
          <xs:element name="keywords" minOccurs="0" maxOccurs="1" type="CT_Keywords"/>
          <xs:element ref="dc:language" minOccurs="0" maxOccurs="1"/>
          <xs:element name="lastModifiedBy" minOccurs="0" maxOccurs="1" type="xs:string"/>
          <xs:element name="lastPrinted" minOccurs="0" maxOccurs="1" type="xs:dateTime"/>
          <xs:element ref="dcterms:modified" minOccurs="0" maxOccurs="1"/>
          <xs:element name="revision" minOccurs="0" maxOccurs="1" type="xs:string"/>
          <xs:element ref="dc:subject" minOccurs="0" maxOccurs="1"/>
          <xs:element ref="dc:title" minOccurs="0" maxOccurs="1"/>
          <xs:element name="version" minOccurs="0" maxOccurs="1" type="xs:string"/>
        </xs:all>
      </xs:complexType>
    
      <xs:complexType name="CT_Keywords" mixed="true">
        <xs:sequence>
          <xs:element name="value" minOccurs="0" maxOccurs="unbounded" type="CT_Keyword"/>
        </xs:sequence>
        <xs:attribute ref="xml:lang" use="optional"/>
      </xs:complexType>
    
      <xs:complexType name="CT_Keyword">
        <xs:simpleContent>
          <xs:extension base="xs:string">
            <xs:attribute ref="xml:lang" use="optional"/>
          </xs:extension>
        </xs:simpleContent>
      </xs:complexType>
    
    </xs:schema>
    
  • docx/ooxml/schemas/ecma/fourth-edition/opc-digSig.xsd2.8 KB4248bf7a39c7upstream ↗
    <?xml version="1.0" encoding="UTF-8"?>
    <xsd:schema xmlns="http://schemas.openxmlformats.org/package/2006/digital-signature"
      xmlns:xsd="http://www.w3.org/2001/XMLSchema"
      targetNamespace="http://schemas.openxmlformats.org/package/2006/digital-signature"
      elementFormDefault="qualified" attributeFormDefault="unqualified" blockDefault="#all">
    
      <xsd:element name="SignatureTime" type="CT_SignatureTime"/>
      <xsd:element name="RelationshipReference" type="CT_RelationshipReference"/>
      <xsd:element name="RelationshipsGroupReference" type="CT_RelationshipsGroupReference"/>
    
      <xsd:complexType name="CT_SignatureTime">
        <xsd:sequence>
          <xsd:element name="Format" type="ST_Format"/>
          <xsd:element name="Value" type="ST_Value"/>
        </xsd:sequence>
      </xsd:complexType>
    
      <xsd:complexType name="CT_RelationshipReference">
        <xsd:simpleContent>
          <xsd:extension base="xsd:string">
            <xsd:attribute name="SourceId" type="xsd:string" use="required"/>
          </xsd:extension>
        </xsd:simpleContent>
      </xsd:complexType>
    
      <xsd:complexType name="CT_RelationshipsGroupReference">
        <xsd:simpleContent>
          <xsd:extension base="xsd:string">
            <xsd:attribute name="SourceType" type="xsd:anyURI" use="required"/>
          </xsd:extension>
        </xsd:simpleContent>
      </xsd:complexType>
    
      <xsd:simpleType name="ST_Format">
        <xsd:restriction base="xsd:string">
          <xsd:pattern
            value="(YYYY)|(YYYY-MM)|(YYYY-MM-DD)|(YYYY-MM-DDThh:mmTZD)|(YYYY-MM-DDThh:mm:ssTZD)|(YYYY-MM-DDThh:mm:ss.sTZD)"
          />
        </xsd:restriction>
      </xsd:simpleType>
    
      <xsd:simpleType name="ST_Value">
        <xsd:restriction base="xsd:string">
          <xsd:pattern
            value="(([0-9][0-9][0-9][0-9]))|(([0-9][0-9][0-9][0-9])-((0[1-9])|(1(0|1|2))))|(([0-9][0-9][0-9][0-9])-((0[1-9])|(1(0|1|2)))-((0[1-9])|(1[0-9])|(2[0-9])|(3(0|1))))|(([0-9][0-9][0-9][0-9])-((0[1-9])|(1(0|1|2)))-((0[1-9])|(1[0-9])|(2[0-9])|(3(0|1)))T((0[0-9])|(1[0-9])|(2(0|1|2|3))):((0[0-9])|(1[0-9])|(2[0-9])|(3[0-9])|(4[0-9])|(5[0-9]))(((\+|-)((0[0-9])|(1[0-9])|(2(0|1|2|3))):((0[0-9])|(1[0-9])|(2[0-9])|(3[0-9])|(4[0-9])|(5[0-9])))|Z))|(([0-9][0-9][0-9][0-9])-((0[1-9])|(1(0|1|2)))-((0[1-9])|(1[0-9])|(2[0-9])|(3(0|1)))T((0[0-9])|(1[0-9])|(2(0|1|2|3))):((0[0-9])|(1[0-9])|(2[0-9])|(3[0-9])|(4[0-9])|(5[0-9])):((0[0-9])|(1[0-9])|(2[0-9])|(3[0-9])|(4[0-9])|(5[0-9]))(((\+|-)((0[0-9])|(1[0-9])|(2(0|1|2|3))):((0[0-9])|(1[0-9])|(2[0-9])|(3[0-9])|(4[0-9])|(5[0-9])))|Z))|(([0-9][0-9][0-9][0-9])-((0[1-9])|(1(0|1|2)))-((0[1-9])|(1[0-9])|(2[0-9])|(3(0|1)))T((0[0-9])|(1[0-9])|(2(0|1|2|3))):((0[0-9])|(1[0-9])|(2[0-9])|(3[0-9])|(4[0-9])|(5[0-9])):(((0[0-9])|(1[0-9])|(2[0-9])|(3[0-9])|(4[0-9])|(5[0-9]))\.[0-9])(((\+|-)((0[0-9])|(1[0-9])|(2(0|1|2|3))):((0[0-9])|(1[0-9])|(2[0-9])|(3[0-9])|(4[0-9])|(5[0-9])))|Z))"
          />
        </xsd:restriction>
      </xsd:simpleType>
    </xsd:schema>
    
  • docx/ooxml/schemas/ecma/fourth-edition/opc-relationships.xsd1.3 KB56497467120bupstream ↗
    <?xml version="1.0" encoding="UTF-8" standalone="no"?>
    <xsd:schema xmlns="http://schemas.openxmlformats.org/package/2006/relationships"
      xmlns:xsd="http://www.w3.org/2001/XMLSchema"
      targetNamespace="http://schemas.openxmlformats.org/package/2006/relationships"
      elementFormDefault="qualified" attributeFormDefault="unqualified" blockDefault="#all">
    
      <xsd:element name="Relationships" type="CT_Relationships"/>
      <xsd:element name="Relationship" type="CT_Relationship"/>
    
      <xsd:complexType name="CT_Relationships">
        <xsd:sequence>
          <xsd:element ref="Relationship" minOccurs="0" maxOccurs="unbounded"/>
        </xsd:sequence>
      </xsd:complexType>
    
      <xsd:complexType name="CT_Relationship">
        <xsd:simpleContent>
          <xsd:extension base="xsd:string">
            <xsd:attribute name="TargetMode" type="ST_TargetMode" use="optional"/>
            <xsd:attribute name="Target" type="xsd:anyURI" use="required"/>
            <xsd:attribute name="Type" type="xsd:anyURI" use="required"/>
            <xsd:attribute name="Id" type="xsd:ID" use="required"/>
          </xsd:extension>
        </xsd:simpleContent>
      </xsd:complexType>
    
      <xsd:simpleType name="ST_TargetMode">
        <xsd:restriction base="xsd:string">
          <xsd:enumeration value="External"/>
          <xsd:enumeration value="Internal"/>
        </xsd:restriction>
      </xsd:simpleType>
    </xsd:schema>
    
  • docx/ooxml/schemas/ISO-IEC29500-4_2016/dml-chart.xsd73 KB6454ef9a94d5upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • docx/ooxml/schemas/ISO-IEC29500-4_2016/dml-chartDrawing.xsd6.8 KBafa4f463e314upstream ↗
    <?xml version="1.0" encoding="utf-8"?>
    <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
      xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main"
      xmlns="http://schemas.openxmlformats.org/drawingml/2006/chartDrawing"
      targetNamespace="http://schemas.openxmlformats.org/drawingml/2006/chartDrawing"
      elementFormDefault="qualified">
      <xsd:import namespace="http://schemas.openxmlformats.org/drawingml/2006/main"
        schemaLocation="dml-main.xsd"/>
      <xsd:complexType name="CT_ShapeNonVisual">
        <xsd:sequence>
          <xsd:element name="cNvPr" type="a:CT_NonVisualDrawingProps" minOccurs="1" maxOccurs="1"/>
          <xsd:element name="cNvSpPr" type="a:CT_NonVisualDrawingShapeProps" minOccurs="1" maxOccurs="1"
          />
        </xsd:sequence>
      </xsd:complexType>
      <xsd:complexType name="CT_Shape">
        <xsd:sequence>
          <xsd:element name="nvSpPr" type="CT_ShapeNonVisual" minOccurs="1" maxOccurs="1"/>
          <xsd:element name="spPr" type="a:CT_ShapeProperties" minOccurs="1" maxOccurs="1"/>
          <xsd:element name="style" type="a:CT_ShapeStyle" minOccurs="0" maxOccurs="1"/>
          <xsd:element name="txBody" type="a:CT_TextBody" minOccurs="0" maxOccurs="1"/>
        </xsd:sequence>
        <xsd:attribute name="macro" type="xsd:string" use="optional"/>
        <xsd:attribute name="textlink" type="xsd:string" use="optional"/>
        <xsd:attribute name="fLocksText" type="xsd:boolean" use="optional" default="true"/>
        <xsd:attribute name="fPublished" type="xsd:boolean" use="optional" default="false"/>
      </xsd:complexType>
      <xsd:complexType name="CT_ConnectorNonVisual">
        <xsd:sequence>
          <xsd:element name="cNvPr" type="a:CT_NonVisualDrawingProps" minOccurs="1" maxOccurs="1"/>
          <xsd:element name="cNvCxnSpPr" type="a:CT_NonVisualConnectorProperties" minOccurs="1"
            maxOccurs="1"/>
        </xsd:sequence>
      </xsd:complexType>
      <xsd:complexType name="CT_Connector">
        <xsd:sequence>
          <xsd:element name="nvCxnSpPr" type="CT_ConnectorNonVisual" minOccurs="1" maxOccurs="1"/>
          <xsd:element name="spPr" type="a:CT_ShapeProperties" minOccurs="1" maxOccurs="1"/>
          <xsd:element name="style" type="a:CT_ShapeStyle" minOccurs="0" maxOccurs="1"/>
        </xsd:sequence>
        <xsd:attribute name="macro" type="xsd:string" use="optional"/>
        <xsd:attribute name="fPublished" type="xsd:boolean" use="optional" default="false"/>
      </xsd:complexType>
      <xsd:complexType name="CT_PictureNonVisual">
        <xsd:sequence>
          <xsd:element name="cNvPr" type="a:CT_NonVisualDrawingProps" minOccurs="1" maxOccurs="1"/>
          <xsd:element name="cNvPicPr" type="a:CT_NonVisualPictureProperties" minOccurs="1"
            maxOccurs="1"/>
        </xsd:sequence>
      </xsd:complexType>
      <xsd:complexType name="CT_Picture">
        <xsd:sequence>
          <xsd:element name="nvPicPr" type="CT_PictureNonVisual" minOccurs="1" maxOccurs="1"/>
          <xsd:element name="blipFill" type="a:CT_BlipFillProperties" minOccurs="1" maxOccurs="1"/>
          <xsd:element name="spPr" type="a:CT_ShapeProperties" minOccurs="1" maxOccurs="1"/>
          <xsd:element name="style" type="a:CT_ShapeStyle" minOccurs="0" maxOccurs="1"/>
        </xsd:sequence>
        <xsd:attribute name="macro" type="xsd:string" use="optional" default=""/>
        <xsd:attribute name="fPublished" type="xsd:boolean" use="optional" default="false"/>
      </xsd:complexType>
      <xsd:complexType name="CT_GraphicFrameNonVisual">
        <xsd:sequence>
          <xsd:element name="cNvPr" type="a:CT_NonVisualDrawingProps" minOccurs="1" maxOccurs="1"/>
          <xsd:element name="cNvGraphicFramePr" type="a:CT_NonVisualGraphicFrameProperties"
            minOccurs="1" maxOccurs="1"/>
        </xsd:sequence>
      </xsd:complexType>
      <xsd:complexType name="CT_GraphicFrame">
        <xsd:sequence>
          <xsd:element name="nvGraphicFramePr" type="CT_GraphicFrameNonVisual" minOccurs="1"
            maxOccurs="1"/>
          <xsd:element name="xfrm" type="a:CT_Transform2D" minOccurs="1" maxOccurs="1"/>
          <xsd:element ref="a:graphic" minOccurs="1" maxOccurs="1"/>
        </xsd:sequence>
        <xsd:attribute name="macro" type="xsd:string" use="optional"/>
        <xsd:attribute name="fPublished" type="xsd:boolean" use="optional" default="false"/>
      </xsd:complexType>
      <xsd:complexType name="CT_GroupShapeNonVisual">
        <xsd:sequence>
          <xsd:element name="cNvPr" type="a:CT_NonVisualDrawingProps" minOccurs="1" maxOccurs="1"/>
          <xsd:element name="cNvGrpSpPr" type="a:CT_NonVisualGroupDrawingShapeProps" minOccurs="1"
            maxOccurs="1"/>
        </xsd:sequence>
      </xsd:complexType>
      <xsd:complexType name="CT_GroupShape">
        <xsd:sequence>
          <xsd:element name="nvGrpSpPr" type="CT_GroupShapeNonVisual" minOccurs="1" maxOccurs="1"/>
          <xsd:element name="grpSpPr" type="a:CT_GroupShapeProperties" minOccurs="1" maxOccurs="1"/>
          <xsd:choice minOccurs="0" maxOccurs="unbounded">
            <xsd:element name="sp" type="CT_Shape"/>
            <xsd:element name="grpSp" type="CT_GroupShape"/>
            <xsd:element name="graphicFrame" type="CT_GraphicFrame"/>
            <xsd:element name="cxnSp" type="CT_Connector"/>
            <xsd:element name="pic" type="CT_Picture"/>
          </xsd:choice>
        </xsd:sequence>
      </xsd:complexType>
      <xsd:group name="EG_ObjectChoices">
        <xsd:sequence>
          <xsd:choice minOccurs="1" maxOccurs="1">
            <xsd:element name="sp" type="CT_Shape"/>
            <xsd:element name="grpSp" type="CT_GroupShape"/>
            <xsd:element name="graphicFrame" type="CT_GraphicFrame"/>
            <xsd:element name="cxnSp" type="CT_Connector"/>
            <xsd:element name="pic" type="CT_Picture"/>
          </xsd:choice>
        </xsd:sequence>
      </xsd:group>
      <xsd:simpleType name="ST_MarkerCoordinate">
        <xsd:restriction base="xsd:double">
          <xsd:minInclusive value="0.0"/>
          <xsd:maxInclusive value="1.0"/>
        </xsd:restriction>
      </xsd:simpleType>
      <xsd:complexType name="CT_Marker">
        <xsd:sequence>
          <xsd:element name="x" type="ST_MarkerCoordinate" minOccurs="1" maxOccurs="1"/>
          <xsd:element name="y" type="ST_MarkerCoordinate" minOccurs="1" maxOccurs="1"/>
        </xsd:sequence>
      </xsd:complexType>
      <xsd:complexType name="CT_RelSizeAnchor">
        <xsd:sequence>
          <xsd:element name="from" type="CT_Marker"/>
          <xsd:element name="to" type="CT_Marker"/>
          <xsd:group ref="EG_ObjectChoices"/>
        </xsd:sequence>
      </xsd:complexType>
      <xsd:complexType name="CT_AbsSizeAnchor">
        <xsd:sequence>
          <xsd:element name="from" type="CT_Marker"/>
          <xsd:element name="ext" type="a:CT_PositiveSize2D"/>
          <xsd:group ref="EG_ObjectChoices"/>
        </xsd:sequence>
      </xsd:complexType>
      <xsd:group name="EG_Anchor">
        <xsd:choice>
          <xsd:element name="relSizeAnchor" type="CT_RelSizeAnchor"/>
          <xsd:element name="absSizeAnchor" type="CT_AbsSizeAnchor"/>
        </xsd:choice>
      </xsd:group>
      <xsd:complexType name="CT_Drawing">
        <xsd:sequence>
          <xsd:group ref="EG_Anchor" minOccurs="0" maxOccurs="unbounded"/>
        </xsd:sequence>
      </xsd:complexType>
    </xsd:schema>
    
  • docx/ooxml/schemas/ISO-IEC29500-4_2016/dml-diagram.xsd50 KB64e66b8abd49upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • docx/ooxml/schemas/ISO-IEC29500-4_2016/dml-lockedCanvas.xsd624 B687eea8297caupstream ↗
    <?xml version="1.0" encoding="utf-8"?>
    <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
      xmlns="http://schemas.openxmlformats.org/drawingml/2006/lockedCanvas"
      xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main"
      xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"
      elementFormDefault="qualified"
      targetNamespace="http://schemas.openxmlformats.org/drawingml/2006/lockedCanvas">
      <xsd:import namespace="http://schemas.openxmlformats.org/drawingml/2006/main"
        schemaLocation="dml-main.xsd"/>
      <xsd:element name="lockedCanvas" type="a:CT_GvmlGroupShape"/>
    </xsd:schema>
    
  • docx/ooxml/schemas/ISO-IEC29500-4_2016/dml-main.xsd149 KBed023d3ff1a3upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • docx/ooxml/schemas/ISO-IEC29500-4_2016/dml-picture.xsd1.2 KB1dbf05140d07upstream ↗
    <?xml version="1.0" encoding="utf-8"?>
    <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
      xmlns="http://schemas.openxmlformats.org/drawingml/2006/picture"
      xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main" elementFormDefault="qualified"
      targetNamespace="http://schemas.openxmlformats.org/drawingml/2006/picture">
      <xsd:import namespace="http://schemas.openxmlformats.org/drawingml/2006/main"
        schemaLocation="dml-main.xsd"/>
      <xsd:complexType name="CT_PictureNonVisual">
        <xsd:sequence>
          <xsd:element name="cNvPr" type="a:CT_NonVisualDrawingProps" minOccurs="1" maxOccurs="1"/>
          <xsd:element name="cNvPicPr" type="a:CT_NonVisualPictureProperties" minOccurs="1"
            maxOccurs="1"/>
        </xsd:sequence>
      </xsd:complexType>
      <xsd:complexType name="CT_Picture">
        <xsd:sequence minOccurs="1" maxOccurs="1">
          <xsd:element name="nvPicPr" type="CT_PictureNonVisual" minOccurs="1" maxOccurs="1"/>
          <xsd:element name="blipFill" type="a:CT_BlipFillProperties" minOccurs="1" maxOccurs="1"/>
          <xsd:element name="spPr" type="a:CT_ShapeProperties" minOccurs="1" maxOccurs="1"/>
        </xsd:sequence>
      </xsd:complexType>
      <xsd:element name="pic" type="CT_Picture"/>
    </xsd:schema>
    
  • docx/ooxml/schemas/ISO-IEC29500-4_2016/dml-spreadsheetDrawing.xsd8.7 KBf1af17db4e83upstream ↗
    <?xml version="1.0" encoding="utf-8"?>
    <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
      xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main"
      xmlns="http://schemas.openxmlformats.org/drawingml/2006/spreadsheetDrawing"
      xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"
      targetNamespace="http://schemas.openxmlformats.org/drawingml/2006/spreadsheetDrawing"
      elementFormDefault="qualified">
      <xsd:import namespace="http://schemas.openxmlformats.org/drawingml/2006/main"
        schemaLocation="dml-main.xsd"/>
      <xsd:import schemaLocation="shared-relationshipReference.xsd"
        namespace="http://schemas.openxmlformats.org/officeDocument/2006/relationships"/>
      <xsd:element name="from" type="CT_Marker"/>
      <xsd:element name="to" type="CT_Marker"/>
      <xsd:complexType name="CT_AnchorClientData">
        <xsd:attribute name="fLocksWithSheet" type="xsd:boolean" use="optional" default="true"/>
        <xsd:attribute name="fPrintsWithSheet" type="xsd:boolean" use="optional" default="true"/>
      </xsd:complexType>
      <xsd:complexType name="CT_ShapeNonVisual">
        <xsd:sequence>
          <xsd:element name="cNvPr" type="a:CT_NonVisualDrawingProps" minOccurs="1" maxOccurs="1"/>
          <xsd:element name="cNvSpPr" type="a:CT_NonVisualDrawingShapeProps" minOccurs="1" maxOccurs="1"
          />
        </xsd:sequence>
      </xsd:complexType>
      <xsd:complexType name="CT_Shape">
        <xsd:sequence>
          <xsd:element name="nvSpPr" type="CT_ShapeNonVisual" minOccurs="1" maxOccurs="1"/>
          <xsd:element name="spPr" type="a:CT_ShapeProperties" minOccurs="1" maxOccurs="1"/>
          <xsd:element name="style" type="a:CT_ShapeStyle" minOccurs="0" maxOccurs="1"/>
          <xsd:element name="txBody" type="a:CT_TextBody" minOccurs="0" maxOccurs="1"/>
        </xsd:sequence>
        <xsd:attribute name="macro" type="xsd:string" use="optional"/>
        <xsd:attribute name="textlink" type="xsd:string" use="optional"/>
        <xsd:attribute name="fLocksText" type="xsd:boolean" use="optional" default="true"/>
        <xsd:attribute name="fPublished" type="xsd:boolean" use="optional" default="false"/>
      </xsd:complexType>
      <xsd:complexType name="CT_ConnectorNonVisual">
        <xsd:sequence>
          <xsd:element name="cNvPr" type="a:CT_NonVisualDrawingProps" minOccurs="1" maxOccurs="1"/>
          <xsd:element name="cNvCxnSpPr" type="a:CT_NonVisualConnectorProperties" minOccurs="1"
            maxOccurs="1"/>
        </xsd:sequence>
      </xsd:complexType>
      <xsd:complexType name="CT_Connector">
        <xsd:sequence>
          <xsd:element name="nvCxnSpPr" type="CT_ConnectorNonVisual" minOccurs="1" maxOccurs="1"/>
          <xsd:element name="spPr" type="a:CT_ShapeProperties" minOccurs="1" maxOccurs="1"/>
          <xsd:element name="style" type="a:CT_ShapeStyle" minOccurs="0" maxOccurs="1"/>
        </xsd:sequence>
        <xsd:attribute name="macro" type="xsd:string" use="optional"/>
        <xsd:attribute name="fPublished" type="xsd:boolean" use="optional" default="false"/>
      </xsd:complexType>
      <xsd:complexType name="CT_PictureNonVisual">
        <xsd:sequence>
          <xsd:element name="cNvPr" type="a:CT_NonVisualDrawingProps" minOccurs="1" maxOccurs="1"/>
          <xsd:element name="cNvPicPr" type="a:CT_NonVisualPictureProperties" minOccurs="1"
            maxOccurs="1"/>
        </xsd:sequence>
      </xsd:complexType>
      <xsd:complexType name="CT_Picture">
        <xsd:sequence>
          <xsd:element name="nvPicPr" type="CT_PictureNonVisual" minOccurs="1" maxOccurs="1"/>
          <xsd:element name="blipFill" type="a:CT_BlipFillProperties" minOccurs="1" maxOccurs="1"/>
          <xsd:element name="spPr" type="a:CT_ShapeProperties" minOccurs="1" maxOccurs="1"/>
          <xsd:element name="style" type="a:CT_ShapeStyle" minOccurs="0" maxOccurs="1"/>
        </xsd:sequence>
        <xsd:attribute name="macro" type="xsd:string" use="optional" default=""/>
        <xsd:attribute name="fPublished" type="xsd:boolean" use="optional" default="false"/>
      </xsd:complexType>
      <xsd:complexType name="CT_GraphicalObjectFrameNonVisual">
        <xsd:sequence>
          <xsd:element name="cNvPr" type="a:CT_NonVisualDrawingProps" minOccurs="1" maxOccurs="1"/>
          <xsd:element name="cNvGraphicFramePr" type="a:CT_NonVisualGraphicFrameProperties"
            minOccurs="1" maxOccurs="1"/>
        </xsd:sequence>
      </xsd:complexType>
      <xsd:complexType name="CT_GraphicalObjectFrame">
        <xsd:sequence>
          <xsd:element name="nvGraphicFramePr" type="CT_GraphicalObjectFrameNonVisual" minOccurs="1"
            maxOccurs="1"/>
          <xsd:element name="xfrm" type="a:CT_Transform2D" minOccurs="1" maxOccurs="1"/>
          <xsd:element ref="a:graphic" minOccurs="1" maxOccurs="1"/>
        </xsd:sequence>
        <xsd:attribute name="macro" type="xsd:string" use="optional"/>
        <xsd:attribute name="fPublished" type="xsd:boolean" use="optional" default="false"/>
      </xsd:complexType>
      <xsd:complexType name="CT_GroupShapeNonVisual">
        <xsd:sequence>
          <xsd:element name="cNvPr" type="a:CT_NonVisualDrawingProps" minOccurs="1" maxOccurs="1"/>
          <xsd:element name="cNvGrpSpPr" type="a:CT_NonVisualGroupDrawingShapeProps" minOccurs="1"
            maxOccurs="1"/>
        </xsd:sequence>
      </xsd:complexType>
      <xsd:complexType name="CT_GroupShape">
        <xsd:sequence>
          <xsd:element name="nvGrpSpPr" type="CT_GroupShapeNonVisual" minOccurs="1" maxOccurs="1"/>
          <xsd:element name="grpSpPr" type="a:CT_GroupShapeProperties" minOccurs="1" maxOccurs="1"/>
          <xsd:choice minOccurs="0" maxOccurs="unbounded">
            <xsd:element name="sp" type="CT_Shape"/>
            <xsd:element name="grpSp" type="CT_GroupShape"/>
            <xsd:element name="graphicFrame" type="CT_GraphicalObjectFrame"/>
            <xsd:element name="cxnSp" type="CT_Connector"/>
            <xsd:element name="pic" type="CT_Picture"/>
          </xsd:choice>
        </xsd:sequence>
      </xsd:complexType>
      <xsd:group name="EG_ObjectChoices">
        <xsd:sequence>
          <xsd:choice minOccurs="1" maxOccurs="1">
            <xsd:element name="sp" type="CT_Shape"/>
            <xsd:element name="grpSp" type="CT_GroupShape"/>
            <xsd:element name="graphicFrame" type="CT_GraphicalObjectFrame"/>
            <xsd:element name="cxnSp" type="CT_Connector"/>
            <xsd:element name="pic" type="CT_Picture"/>
            <xsd:element name="contentPart" type="CT_Rel"/>
          </xsd:choice>
        </xsd:sequence>
      </xsd:group>
      <xsd:complexType name="CT_Rel">
        <xsd:attribute ref="r:id" use="required"/>
      </xsd:complexType>
      <xsd:simpleType name="ST_ColID">
        <xsd:restriction base="xsd:int">
          <xsd:minInclusive value="0"/>
        </xsd:restriction>
      </xsd:simpleType>
      <xsd:simpleType name="ST_RowID">
        <xsd:restriction base="xsd:int">
          <xsd:minInclusive value="0"/>
        </xsd:restriction>
      </xsd:simpleType>
      <xsd:complexType name="CT_Marker">
        <xsd:sequence>
          <xsd:element name="col" type="ST_ColID"/>
          <xsd:element name="colOff" type="a:ST_Coordinate"/>
          <xsd:element name="row" type="ST_RowID"/>
          <xsd:element name="rowOff" type="a:ST_Coordinate"/>
        </xsd:sequence>
      </xsd:complexType>
      <xsd:simpleType name="ST_EditAs">
        <xsd:restriction base="xsd:token">
          <xsd:enumeration value="twoCell"/>
          <xsd:enumeration value="oneCell"/>
          <xsd:enumeration value="absolute"/>
        </xsd:restriction>
      </xsd:simpleType>
      <xsd:complexType name="CT_TwoCellAnchor">
        <xsd:sequence>
          <xsd:element name="from" type="CT_Marker"/>
          <xsd:element name="to" type="CT_Marker"/>
          <xsd:group ref="EG_ObjectChoices"/>
          <xsd:element name="clientData" type="CT_AnchorClientData" minOccurs="1" maxOccurs="1"/>
        </xsd:sequence>
        <xsd:attribute name="editAs" type="ST_EditAs" use="optional" default="twoCell"/>
      </xsd:complexType>
      <xsd:complexType name="CT_OneCellAnchor">
        <xsd:sequence>
          <xsd:element name="from" type="CT_Marker"/>
          <xsd:element name="ext" type="a:CT_PositiveSize2D"/>
          <xsd:group ref="EG_ObjectChoices"/>
          <xsd:element name="clientData" type="CT_AnchorClientData" minOccurs="1" maxOccurs="1"/>
        </xsd:sequence>
      </xsd:complexType>
      <xsd:complexType name="CT_AbsoluteAnchor">
        <xsd:sequence>
          <xsd:element name="pos" type="a:CT_Point2D"/>
          <xsd:element name="ext" type="a:CT_PositiveSize2D"/>
          <xsd:group ref="EG_ObjectChoices"/>
          <xsd:element name="clientData" type="CT_AnchorClientData" minOccurs="1" maxOccurs="1"/>
        </xsd:sequence>
      </xsd:complexType>
      <xsd:group name="EG_Anchor">
        <xsd:choice>
          <xsd:element name="twoCellAnchor" type="CT_TwoCellAnchor"/>
          <xsd:element name="oneCellAnchor" type="CT_OneCellAnchor"/>
          <xsd:element name="absoluteAnchor" type="CT_AbsoluteAnchor"/>
        </xsd:choice>
      </xsd:group>
      <xsd:complexType name="CT_Drawing">
        <xsd:sequence>
          <xsd:group ref="EG_Anchor" minOccurs="0" maxOccurs="unbounded"/>
        </xsd:sequence>
      </xsd:complexType>
      <xsd:element name="wsDr" type="CT_Drawing"/>
    </xsd:schema>
    
  • docx/ooxml/schemas/ISO-IEC29500-4_2016/dml-wordprocessingDrawing.xsd14 KB0a185ab6ed0cupstream ↗
    <?xml version="1.0" encoding="utf-8"?>
    <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
      xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main"
      xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"
      xmlns:dpct="http://schemas.openxmlformats.org/drawingml/2006/picture"
      xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"
      xmlns="http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing"
      targetNamespace="http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing"
      elementFormDefault="qualified">
      <xsd:import namespace="http://schemas.openxmlformats.org/drawingml/2006/main"
        schemaLocation="dml-main.xsd"/>
      <xsd:import schemaLocation="wml.xsd"
        namespace="http://schemas.openxmlformats.org/wordprocessingml/2006/main"/>
      <xsd:import namespace="http://schemas.openxmlformats.org/drawingml/2006/picture"
        schemaLocation="dml-picture.xsd"/>
      <xsd:import namespace="http://schemas.openxmlformats.org/officeDocument/2006/relationships"
        schemaLocation="shared-relationshipReference.xsd"/>
      <xsd:complexType name="CT_EffectExtent">
        <xsd:attribute name="l" type="a:ST_Coordinate" use="required"/>
        <xsd:attribute name="t" type="a:ST_Coordinate" use="required"/>
        <xsd:attribute name="r" type="a:ST_Coordinate" use="required"/>
        <xsd:attribute name="b" type="a:ST_Coordinate" use="required"/>
      </xsd:complexType>
      <xsd:simpleType name="ST_WrapDistance">
        <xsd:restriction base="xsd:unsignedInt"/>
      </xsd:simpleType>
      <xsd:complexType name="CT_Inline">
        <xsd:sequence>
          <xsd:element name="extent" type="a:CT_PositiveSize2D"/>
          <xsd:element name="effectExtent" type="CT_EffectExtent" minOccurs="0"/>
          <xsd:element name="docPr" type="a:CT_NonVisualDrawingProps" minOccurs="1" maxOccurs="1"/>
          <xsd:element name="cNvGraphicFramePr" type="a:CT_NonVisualGraphicFrameProperties"
            minOccurs="0" maxOccurs="1"/>
          <xsd:element ref="a:graphic" minOccurs="1" maxOccurs="1"/>
        </xsd:sequence>
        <xsd:attribute name="distT" type="ST_WrapDistance" use="optional"/>
        <xsd:attribute name="distB" type="ST_WrapDistance" use="optional"/>
        <xsd:attribute name="distL" type="ST_WrapDistance" use="optional"/>
        <xsd:attribute name="distR" type="ST_WrapDistance" use="optional"/>
      </xsd:complexType>
      <xsd:simpleType name="ST_WrapText">
        <xsd:restriction base="xsd:token">
          <xsd:enumeration value="bothSides"/>
          <xsd:enumeration value="left"/>
          <xsd:enumeration value="right"/>
          <xsd:enumeration value="largest"/>
        </xsd:restriction>
      </xsd:simpleType>
      <xsd:complexType name="CT_WrapPath">
        <xsd:sequence>
          <xsd:element name="start" type="a:CT_Point2D" minOccurs="1" maxOccurs="1"/>
          <xsd:element name="lineTo" type="a:CT_Point2D" minOccurs="2" maxOccurs="unbounded"/>
        </xsd:sequence>
        <xsd:attribute name="edited" type="xsd:boolean" use="optional"/>
      </xsd:complexType>
      <xsd:complexType name="CT_WrapNone"/>
      <xsd:complexType name="CT_WrapSquare">
        <xsd:sequence>
          <xsd:element name="effectExtent" type="CT_EffectExtent" minOccurs="0"/>
        </xsd:sequence>
        <xsd:attribute name="wrapText" type="ST_WrapText" use="required"/>
        <xsd:attribute name="distT" type="ST_WrapDistance" use="optional"/>
        <xsd:attribute name="distB" type="ST_WrapDistance" use="optional"/>
        <xsd:attribute name="distL" type="ST_WrapDistance" use="optional"/>
        <xsd:attribute name="distR" type="ST_WrapDistance" use="optional"/>
      </xsd:complexType>
      <xsd:complexType name="CT_WrapTight">
        <xsd:sequence>
          <xsd:element name="wrapPolygon" type="CT_WrapPath" minOccurs="1" maxOccurs="1"/>
        </xsd:sequence>
        <xsd:attribute name="wrapText" type="ST_WrapText" use="required"/>
        <xsd:attribute name="distL" type="ST_WrapDistance" use="optional"/>
        <xsd:attribute name="distR" type="ST_WrapDistance" use="optional"/>
      </xsd:complexType>
      <xsd:complexType name="CT_WrapThrough">
        <xsd:sequence>
          <xsd:element name="wrapPolygon" type="CT_WrapPath" minOccurs="1" maxOccurs="1"/>
        </xsd:sequence>
        <xsd:attribute name="wrapText" type="ST_WrapText" use="required"/>
        <xsd:attribute name="distL" type="ST_WrapDistance" use="optional"/>
        <xsd:attribute name="distR" type="ST_WrapDistance" use="optional"/>
      </xsd:complexType>
      <xsd:complexType name="CT_WrapTopBottom">
        <xsd:sequence>
          <xsd:element name="effectExtent" type="CT_EffectExtent" minOccurs="0"/>
        </xsd:sequence>
        <xsd:attribute name="distT" type="ST_WrapDistance" use="optional"/>
        <xsd:attribute name="distB" type="ST_WrapDistance" use="optional"/>
      </xsd:complexType>
      <xsd:group name="EG_WrapType">
        <xsd:sequence>
          <xsd:choice minOccurs="1" maxOccurs="1">
            <xsd:element name="wrapNone" type="CT_WrapNone" minOccurs="1" maxOccurs="1"/>
            <xsd:element name="wrapSquare" type="CT_WrapSquare" minOccurs="1" maxOccurs="1"/>
            <xsd:element name="wrapTight" type="CT_WrapTight" minOccurs="1" maxOccurs="1"/>
            <xsd:element name="wrapThrough" type="CT_WrapThrough" minOccurs="1" maxOccurs="1"/>
            <xsd:element name="wrapTopAndBottom" type="CT_WrapTopBottom" minOccurs="1" maxOccurs="1"/>
          </xsd:choice>
        </xsd:sequence>
      </xsd:group>
      <xsd:simpleType name="ST_PositionOffset">
        <xsd:restriction base="xsd:int"/>
      </xsd:simpleType>
      <xsd:simpleType name="ST_AlignH">
        <xsd:restriction base="xsd:token">
          <xsd:enumeration value="left"/>
          <xsd:enumeration value="right"/>
          <xsd:enumeration value="center"/>
          <xsd:enumeration value="inside"/>
          <xsd:enumeration value="outside"/>
        </xsd:restriction>
      </xsd:simpleType>
      <xsd:simpleType name="ST_RelFromH">
        <xsd:restriction base="xsd:token">
          <xsd:enumeration value="margin"/>
          <xsd:enumeration value="page"/>
          <xsd:enumeration value="column"/>
          <xsd:enumeration value="character"/>
          <xsd:enumeration value="leftMargin"/>
          <xsd:enumeration value="rightMargin"/>
          <xsd:enumeration value="insideMargin"/>
          <xsd:enumeration value="outsideMargin"/>
        </xsd:restriction>
      </xsd:simpleType>
      <xsd:complexType name="CT_PosH">
        <xsd:sequence>
          <xsd:choice minOccurs="1" maxOccurs="1">
            <xsd:element name="align" type="ST_AlignH" minOccurs="1" maxOccurs="1"/>
            <xsd:element name="posOffset" type="ST_PositionOffset" minOccurs="1" maxOccurs="1"/>
          </xsd:choice>
        </xsd:sequence>
        <xsd:attribute name="relativeFrom" type="ST_RelFromH" use="required"/>
      </xsd:complexType>
      <xsd:simpleType name="ST_AlignV">
        <xsd:restriction base="xsd:token">
          <xsd:enumeration value="top"/>
          <xsd:enumeration value="bottom"/>
          <xsd:enumeration value="center"/>
          <xsd:enumeration value="inside"/>
          <xsd:enumeration value="outside"/>
        </xsd:restriction>
      </xsd:simpleType>
      <xsd:simpleType name="ST_RelFromV">
        <xsd:restriction base="xsd:token">
          <xsd:enumeration value="margin"/>
          <xsd:enumeration value="page"/>
          <xsd:enumeration value="paragraph"/>
          <xsd:enumeration value="line"/>
          <xsd:enumeration value="topMargin"/>
          <xsd:enumeration value="bottomMargin"/>
          <xsd:enumeration value="insideMargin"/>
          <xsd:enumeration value="outsideMargin"/>
        </xsd:restriction>
      </xsd:simpleType>
      <xsd:complexType name="CT_PosV">
        <xsd:sequence>
          <xsd:choice minOccurs="1" maxOccurs="1">
            <xsd:element name="align" type="ST_AlignV" minOccurs="1" maxOccurs="1"/>
            <xsd:element name="posOffset" type="ST_PositionOffset" minOccurs="1" maxOccurs="1"/>
          </xsd:choice>
        </xsd:sequence>
        <xsd:attribute name="relativeFrom" type="ST_RelFromV" use="required"/>
      </xsd:complexType>
      <xsd:complexType name="CT_Anchor">
        <xsd:sequence>
          <xsd:element name="simplePos" type="a:CT_Point2D"/>
          <xsd:element name="positionH" type="CT_PosH"/>
          <xsd:element name="positionV" type="CT_PosV"/>
          <xsd:element name="extent" type="a:CT_PositiveSize2D"/>
          <xsd:element name="effectExtent" type="CT_EffectExtent" minOccurs="0"/>
          <xsd:group ref="EG_WrapType"/>
          <xsd:element name="docPr" type="a:CT_NonVisualDrawingProps" minOccurs="1" maxOccurs="1"/>
          <xsd:element name="cNvGraphicFramePr" type="a:CT_NonVisualGraphicFrameProperties"
            minOccurs="0" maxOccurs="1"/>
          <xsd:element ref="a:graphic" minOccurs="1" maxOccurs="1"/>
        </xsd:sequence>
        <xsd:attribute name="distT" type="ST_WrapDistance" use="optional"/>
        <xsd:attribute name="distB" type="ST_WrapDistance" use="optional"/>
        <xsd:attribute name="distL" type="ST_WrapDistance" use="optional"/>
        <xsd:attribute name="distR" type="ST_WrapDistance" use="optional"/>
        <xsd:attribute name="simplePos" type="xsd:boolean"/>
        <xsd:attribute name="relativeHeight" type="xsd:unsignedInt" use="required"/>
        <xsd:attribute name="behindDoc" type="xsd:boolean" use="required"/>
        <xsd:attribute name="locked" type="xsd:boolean" use="required"/>
        <xsd:attribute name="layoutInCell" type="xsd:boolean" use="required"/>
        <xsd:attribute name="hidden" type="xsd:boolean" use="optional"/>
        <xsd:attribute name="allowOverlap" type="xsd:boolean" use="required"/>
      </xsd:complexType>
      <xsd:complexType name="CT_TxbxContent">
        <xsd:group ref="w:EG_BlockLevelElts" minOccurs="1" maxOccurs="unbounded"/>
      </xsd:complexType>
      <xsd:complexType name="CT_TextboxInfo">
        <xsd:sequence>
          <xsd:element name="txbxContent" type="CT_TxbxContent" minOccurs="1" maxOccurs="1"/>
          <xsd:element name="extLst" type="a:CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/>
        </xsd:sequence>
        <xsd:attribute name="id" type="xsd:unsignedShort" use="optional" default="0"/>
      </xsd:complexType>
      <xsd:complexType name="CT_LinkedTextboxInformation">
        <xsd:sequence>
          <xsd:element name="extLst" type="a:CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/>
        </xsd:sequence>
        <xsd:attribute name="id" type="xsd:unsignedShort" use="required"/>
        <xsd:attribute name="seq" type="xsd:unsignedShort" use="required"/>
      </xsd:complexType>
      <xsd:complexType name="CT_WordprocessingShape">
        <xsd:sequence minOccurs="1" maxOccurs="1">
          <xsd:element name="cNvPr" type="a:CT_NonVisualDrawingProps" minOccurs="0" maxOccurs="1"/>
          <xsd:choice minOccurs="1" maxOccurs="1">
            <xsd:element name="cNvSpPr" type="a:CT_NonVisualDrawingShapeProps" minOccurs="1"
              maxOccurs="1"/>
            <xsd:element name="cNvCnPr" type="a:CT_NonVisualConnectorProperties" minOccurs="1"
              maxOccurs="1"/>
          </xsd:choice>
          <xsd:element name="spPr" type="a:CT_ShapeProperties" minOccurs="1" maxOccurs="1"/>
          <xsd:element name="style" type="a:CT_ShapeStyle" minOccurs="0" maxOccurs="1"/>
          <xsd:element name="extLst" type="a:CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/>
          <xsd:choice minOccurs="0" maxOccurs="1">
            <xsd:element name="txbx" type="CT_TextboxInfo" minOccurs="1" maxOccurs="1"/>
            <xsd:element name="linkedTxbx" type="CT_LinkedTextboxInformation" minOccurs="1"
              maxOccurs="1"/>
          </xsd:choice>
          <xsd:element name="bodyPr" type="a:CT_TextBodyProperties" minOccurs="1" maxOccurs="1"/>
        </xsd:sequence>
        <xsd:attribute name="normalEastAsianFlow" type="xsd:boolean" use="optional" default="false"/>
      </xsd:complexType>
      <xsd:complexType name="CT_GraphicFrame">
        <xsd:sequence>
          <xsd:element name="cNvPr" type="a:CT_NonVisualDrawingProps" minOccurs="1" maxOccurs="1"/>
          <xsd:element name="cNvFrPr" type="a:CT_NonVisualGraphicFrameProperties" minOccurs="1"
            maxOccurs="1"/>
          <xsd:element name="xfrm" type="a:CT_Transform2D" minOccurs="1" maxOccurs="1"/>
          <xsd:element ref="a:graphic" minOccurs="1" maxOccurs="1"/>
          <xsd:element name="extLst" type="a:CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/>
        </xsd:sequence>
      </xsd:complexType>
      <xsd:complexType name="CT_WordprocessingContentPartNonVisual">
        <xsd:sequence>
          <xsd:element name="cNvPr" type="a:CT_NonVisualDrawingProps" minOccurs="0" maxOccurs="1"/>
          <xsd:element name="cNvContentPartPr" type="a:CT_NonVisualContentPartProperties" minOccurs="0" maxOccurs="1"/>
        </xsd:sequence>
      </xsd:complexType>
      <xsd:complexType name="CT_WordprocessingContentPart">
        <xsd:sequence>
          <xsd:element name="nvContentPartPr" type="CT_WordprocessingContentPartNonVisual" minOccurs="0" maxOccurs="1"/>
          <xsd:element name="xfrm" type="a:CT_Transform2D" minOccurs="0" maxOccurs="1"/>
          <xsd:element name="extLst" type="a:CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/>
        </xsd:sequence>
        <xsd:attribute name="bwMode" type="a:ST_BlackWhiteMode" use="optional"/>
        <xsd:attribute ref="r:id" use="required"/>
      </xsd:complexType>
      <xsd:complexType name="CT_WordprocessingGroup">
        <xsd:sequence minOccurs="1" maxOccurs="1">
          <xsd:element name="cNvPr" type="a:CT_NonVisualDrawingProps" minOccurs="0" maxOccurs="1"/>
          <xsd:element name="cNvGrpSpPr" type="a:CT_NonVisualGroupDrawingShapeProps" minOccurs="1"
            maxOccurs="1"/>
          <xsd:element name="grpSpPr" type="a:CT_GroupShapeProperties" minOccurs="1" maxOccurs="1"/>
          <xsd:choice minOccurs="0" maxOccurs="unbounded">
            <xsd:element ref="wsp"/>
            <xsd:element name="grpSp" type="CT_WordprocessingGroup"/>
            <xsd:element name="graphicFrame" type="CT_GraphicFrame"/>
            <xsd:element ref="dpct:pic"/>
            <xsd:element name="contentPart" type="CT_WordprocessingContentPart"/>
          </xsd:choice>
          <xsd:element name="extLst" type="a:CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/>
        </xsd:sequence>
      </xsd:complexType>
      <xsd:complexType name="CT_WordprocessingCanvas">
        <xsd:sequence minOccurs="1" maxOccurs="1">
          <xsd:element name="bg" type="a:CT_BackgroundFormatting" minOccurs="0" maxOccurs="1"/>
          <xsd:element name="whole" type="a:CT_WholeE2oFormatting" minOccurs="0" maxOccurs="1"/>
          <xsd:choice minOccurs="0" maxOccurs="unbounded">
            <xsd:element ref="wsp"/>
            <xsd:element ref="dpct:pic"/>
            <xsd:element name="contentPart" type="CT_WordprocessingContentPart"/>
            <xsd:element ref="wgp"/>
            <xsd:element name="graphicFrame" type="CT_GraphicFrame"/>
          </xsd:choice>
          <xsd:element name="extLst" type="a:CT_OfficeArtExtensionList" minOccurs="0" maxOccurs="1"/>
        </xsd:sequence>
      </xsd:complexType>
      <xsd:element name="wpc" type="CT_WordprocessingCanvas"/>
      <xsd:element name="wgp" type="CT_WordprocessingGroup"/>
      <xsd:element name="wsp" type="CT_WordprocessingShape"/>
      <xsd:element name="inline" type="CT_Inline"/>
      <xsd:element name="anchor" type="CT_Anchor"/>
    </xsd:schema>
    
  • docx/ooxml/schemas/ISO-IEC29500-4_2016/pml.xsd82 KB14ef488865f3upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • docx/ooxml/schemas/ISO-IEC29500-4_2016/shared-additionalCharacteristics.xsd1.2 KBc20f3bf14720upstream ↗
    <?xml version="1.0" encoding="utf-8"?>
    <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
      xmlns="http://schemas.openxmlformats.org/officeDocument/2006/characteristics"
      targetNamespace="http://schemas.openxmlformats.org/officeDocument/2006/characteristics"
      elementFormDefault="qualified">
      <xsd:complexType name="CT_AdditionalCharacteristics">
        <xsd:sequence>
          <xsd:element name="characteristic" type="CT_Characteristic" minOccurs="0"
            maxOccurs="unbounded"/>
        </xsd:sequence>
      </xsd:complexType>
      <xsd:complexType name="CT_Characteristic">
        <xsd:attribute name="name" type="xsd:string" use="required"/>
        <xsd:attribute name="relation" type="ST_Relation" use="required"/>
        <xsd:attribute name="val" type="xsd:string" use="required"/>
        <xsd:attribute name="vocabulary" type="xsd:anyURI" use="optional"/>
      </xsd:complexType>
      <xsd:simpleType name="ST_Relation">
        <xsd:restriction base="xsd:string">
          <xsd:enumeration value="ge"/>
          <xsd:enumeration value="le"/>
          <xsd:enumeration value="gt"/>
          <xsd:enumeration value="lt"/>
          <xsd:enumeration value="eq"/>
        </xsd:restriction>
      </xsd:simpleType>
      <xsd:element name="additionalCharacteristics" type="CT_AdditionalCharacteristics"/>
    </xsd:schema>
    
  • docx/ooxml/schemas/ISO-IEC29500-4_2016/shared-bibliography.xsd7.2 KBac6025226253upstream ↗
    <?xml version="1.0" encoding="utf-8"?>
    <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
      xmlns="http://schemas.openxmlformats.org/officeDocument/2006/bibliography"
      xmlns:s="http://schemas.openxmlformats.org/officeDocument/2006/sharedTypes"
      targetNamespace="http://schemas.openxmlformats.org/officeDocument/2006/bibliography"
      elementFormDefault="qualified">
      <xsd:import namespace="http://schemas.openxmlformats.org/officeDocument/2006/sharedTypes"
        schemaLocation="shared-commonSimpleTypes.xsd"/>
      <xsd:simpleType name="ST_SourceType">
        <xsd:restriction base="s:ST_String">
          <xsd:enumeration value="ArticleInAPeriodical"/>
          <xsd:enumeration value="Book"/>
          <xsd:enumeration value="BookSection"/>
          <xsd:enumeration value="JournalArticle"/>
          <xsd:enumeration value="ConferenceProceedings"/>
          <xsd:enumeration value="Report"/>
          <xsd:enumeration value="SoundRecording"/>
          <xsd:enumeration value="Performance"/>
          <xsd:enumeration value="Art"/>
          <xsd:enumeration value="DocumentFromInternetSite"/>
          <xsd:enumeration value="InternetSite"/>
          <xsd:enumeration value="Film"/>
          <xsd:enumeration value="Interview"/>
          <xsd:enumeration value="Patent"/>
          <xsd:enumeration value="ElectronicSource"/>
          <xsd:enumeration value="Case"/>
          <xsd:enumeration value="Misc"/>
        </xsd:restriction>
      </xsd:simpleType>
      <xsd:complexType name="CT_NameListType">
        <xsd:sequence>
          <xsd:element name="Person" type="CT_PersonType" minOccurs="1" maxOccurs="unbounded"/>
        </xsd:sequence>
      </xsd:complexType>
      <xsd:complexType name="CT_PersonType">
        <xsd:sequence>
          <xsd:element name="Last" type="s:ST_String" minOccurs="0" maxOccurs="unbounded"/>
          <xsd:element name="First" type="s:ST_String" minOccurs="0" maxOccurs="unbounded"/>
          <xsd:element name="Middle" type="s:ST_String" minOccurs="0" maxOccurs="unbounded"/>
        </xsd:sequence>
      </xsd:complexType>
      <xsd:complexType name="CT_NameType">
        <xsd:sequence>
          <xsd:element name="NameList" type="CT_NameListType" minOccurs="1" maxOccurs="1"/>
        </xsd:sequence>
      </xsd:complexType>
      <xsd:complexType name="CT_NameOrCorporateType">
        <xsd:sequence>
          <xsd:choice minOccurs="0" maxOccurs="1">
            <xsd:element name="NameList" type="CT_NameListType" minOccurs="1" maxOccurs="1"/>
            <xsd:element name="Corporate" minOccurs="1" maxOccurs="1" type="s:ST_String"/>
          </xsd:choice>
        </xsd:sequence>
      </xsd:complexType>
      <xsd:complexType name="CT_AuthorType">
        <xsd:sequence>
          <xsd:choice minOccurs="0" maxOccurs="unbounded">
            <xsd:element name="Artist" type="CT_NameType"/>
            <xsd:element name="Author" type="CT_NameOrCorporateType"/>
            <xsd:element name="BookAuthor" type="CT_NameType"/>
            <xsd:element name="Compiler" type="CT_NameType"/>
            <xsd:element name="Composer" type="CT_NameType"/>
            <xsd:element name="Conductor" type="CT_NameType"/>
            <xsd:element name="Counsel" type="CT_NameType"/>
            <xsd:element name="Director" type="CT_NameType"/>
            <xsd:element name="Editor" type="CT_NameType"/>
            <xsd:element name="Interviewee" type="CT_NameType"/>
            <xsd:element name="Interviewer" type="CT_NameType"/>
            <xsd:element name="Inventor" type="CT_NameType"/>
            <xsd:element name="Performer" type="CT_NameOrCorporateType"/>
            <xsd:element name="ProducerName" type="CT_NameType"/>
            <xsd:element name="Translator" type="CT_NameType"/>
            <xsd:element name="Writer" type="CT_NameType"/>
          </xsd:choice>
        </xsd:sequence>
      </xsd:complexType>
      <xsd:complexType name="CT_SourceType">
        <xsd:sequence>
          <xsd:choice minOccurs="0" maxOccurs="unbounded">
            <xsd:element name="AbbreviatedCaseNumber" type="s:ST_String"/>
            <xsd:element name="AlbumTitle" type="s:ST_String"/>
            <xsd:element name="Author" type="CT_AuthorType"/>
            <xsd:element name="BookTitle" type="s:ST_String"/>
            <xsd:element name="Broadcaster" type="s:ST_String"/>
            <xsd:element name="BroadcastTitle" type="s:ST_String"/>
            <xsd:element name="CaseNumber" type="s:ST_String"/>
            <xsd:element name="ChapterNumber" type="s:ST_String"/>
            <xsd:element name="City" type="s:ST_String"/>
            <xsd:element name="Comments" type="s:ST_String"/>
            <xsd:element name="ConferenceName" type="s:ST_String"/>
            <xsd:element name="CountryRegion" type="s:ST_String"/>
            <xsd:element name="Court" type="s:ST_String"/>
            <xsd:element name="Day" type="s:ST_String"/>
            <xsd:element name="DayAccessed" type="s:ST_String"/>
            <xsd:element name="Department" type="s:ST_String"/>
            <xsd:element name="Distributor" type="s:ST_String"/>
            <xsd:element name="Edition" type="s:ST_String"/>
            <xsd:element name="Guid" type="s:ST_String"/>
            <xsd:element name="Institution" type="s:ST_String"/>
            <xsd:element name="InternetSiteTitle" type="s:ST_String"/>
            <xsd:element name="Issue" type="s:ST_String"/>
            <xsd:element name="JournalName" type="s:ST_String"/>
            <xsd:element name="LCID" type="s:ST_Lang"/>
            <xsd:element name="Medium" type="s:ST_String"/>
            <xsd:element name="Month" type="s:ST_String"/>
            <xsd:element name="MonthAccessed" type="s:ST_String"/>
            <xsd:element name="NumberVolumes" type="s:ST_String"/>
            <xsd:element name="Pages" type="s:ST_String"/>
            <xsd:element name="PatentNumber" type="s:ST_String"/>
            <xsd:element name="PeriodicalTitle" type="s:ST_String"/>
            <xsd:element name="ProductionCompany" type="s:ST_String"/>
            <xsd:element name="PublicationTitle" type="s:ST_String"/>
            <xsd:element name="Publisher" type="s:ST_String"/>
            <xsd:element name="RecordingNumber" type="s:ST_String"/>
            <xsd:element name="RefOrder" type="s:ST_String"/>
            <xsd:element name="Reporter" type="s:ST_String"/>
            <xsd:element name="SourceType" type="ST_SourceType"/>
            <xsd:element name="ShortTitle" type="s:ST_String"/>
            <xsd:element name="StandardNumber" type="s:ST_String"/>
            <xsd:element name="StateProvince" type="s:ST_String"/>
            <xsd:element name="Station" type="s:ST_String"/>
            <xsd:element name="Tag" type="s:ST_String"/>
            <xsd:element name="Theater" type="s:ST_String"/>
            <xsd:element name="ThesisType" type="s:ST_String"/>
            <xsd:element name="Title" type="s:ST_String"/>
            <xsd:element name="Type" type="s:ST_String"/>
            <xsd:element name="URL" type="s:ST_String"/>
            <xsd:element name="Version" type="s:ST_String"/>
            <xsd:element name="Volume" type="s:ST_String"/>
            <xsd:element name="Year" type="s:ST_String"/>
            <xsd:element name="YearAccessed" type="s:ST_String"/>
          </xsd:choice>
        </xsd:sequence>
      </xsd:complexType>
      <xsd:element name="Sources" type="CT_Sources"/>
      <xsd:complexType name="CT_Sources">
        <xsd:sequence>
          <xsd:element name="Source" type="CT_SourceType" minOccurs="0" maxOccurs="unbounded"/>
        </xsd:sequence>
        <xsd:attribute name="SelectedStyle" type="s:ST_String"/>
        <xsd:attribute name="StyleName" type="s:ST_String"/>
        <xsd:attribute name="URI" type="s:ST_String"/>
      </xsd:complexType>
    </xsd:schema>
    
  • docx/ooxml/schemas/ISO-IEC29500-4_2016/shared-commonSimpleTypes.xsd6.2 KB424b8ba8d1f9upstream ↗
    <?xml version="1.0" encoding="utf-8"?>
    <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
      xmlns="http://schemas.openxmlformats.org/officeDocument/2006/sharedTypes"
      targetNamespace="http://schemas.openxmlformats.org/officeDocument/2006/sharedTypes"
      elementFormDefault="qualified">
      <xsd:simpleType name="ST_Lang">
        <xsd:restriction base="xsd:string"/>
      </xsd:simpleType>
      <xsd:simpleType name="ST_HexColorRGB">
        <xsd:restriction base="xsd:hexBinary">
          <xsd:length value="3" fixed="true"/>
        </xsd:restriction>
      </xsd:simpleType>
      <xsd:simpleType name="ST_Panose">
        <xsd:restriction base="xsd:hexBinary">
          <xsd:length value="10"/>
        </xsd:restriction>
      </xsd:simpleType>
      <xsd:simpleType name="ST_CalendarType">
        <xsd:restriction base="xsd:string">
          <xsd:enumeration value="gregorian"/>
          <xsd:enumeration value="gregorianUs"/>
          <xsd:enumeration value="gregorianMeFrench"/>
          <xsd:enumeration value="gregorianArabic"/>
          <xsd:enumeration value="hijri"/>
          <xsd:enumeration value="hebrew"/>
          <xsd:enumeration value="taiwan"/>
          <xsd:enumeration value="japan"/>
          <xsd:enumeration value="thai"/>
          <xsd:enumeration value="korea"/>
          <xsd:enumeration value="saka"/>
          <xsd:enumeration value="gregorianXlitEnglish"/>
          <xsd:enumeration value="gregorianXlitFrench"/>
          <xsd:enumeration value="none"/>
        </xsd:restriction>
      </xsd:simpleType>
      <xsd:simpleType name="ST_AlgClass">
        <xsd:restriction base="xsd:string">
          <xsd:enumeration value="hash"/>
          <xsd:enumeration value="custom"/>
        </xsd:restriction>
      </xsd:simpleType>
      <xsd:simpleType name="ST_CryptProv">
        <xsd:restriction base="xsd:string">
          <xsd:enumeration value="rsaAES"/>
          <xsd:enumeration value="rsaFull"/>
          <xsd:enumeration value="custom"/>
        </xsd:restriction>
      </xsd:simpleType>
      <xsd:simpleType name="ST_AlgType">
        <xsd:restriction base="xsd:string">
          <xsd:enumeration value="typeAny"/>
          <xsd:enumeration value="custom"/>
        </xsd:restriction>
      </xsd:simpleType>
      <xsd:simpleType name="ST_ColorType">
        <xsd:restriction base="xsd:string"/>
      </xsd:simpleType>
      <xsd:simpleType name="ST_Guid">
        <xsd:restriction base="xsd:token">
          <xsd:pattern value="\{[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}\}"/>
        </xsd:restriction>
      </xsd:simpleType>
      <xsd:simpleType name="ST_OnOff">
        <xsd:union memberTypes="xsd:boolean ST_OnOff1"/>
      </xsd:simpleType>
      <xsd:simpleType name="ST_OnOff1">
        <xsd:restriction base="xsd:string">
          <xsd:enumeration value="on"/>
          <xsd:enumeration value="off"/>
        </xsd:restriction>
      </xsd:simpleType>
      <xsd:simpleType name="ST_String">
        <xsd:restriction base="xsd:string"/>
      </xsd:simpleType>
      <xsd:simpleType name="ST_XmlName">
        <xsd:restriction base="xsd:NCName">
          <xsd:minLength value="1"/>
          <xsd:maxLength value="255"/>
        </xsd:restriction>
      </xsd:simpleType>
      <xsd:simpleType name="ST_TrueFalse">
        <xsd:restriction base="xsd:string">
          <xsd:enumeration value="t"/>
          <xsd:enumeration value="f"/>
          <xsd:enumeration value="true"/>
          <xsd:enumeration value="false"/>
        </xsd:restriction>
      </xsd:simpleType>
      <xsd:simpleType name="ST_TrueFalseBlank">
        <xsd:restriction base="xsd:string">
          <xsd:enumeration value="t"/>
          <xsd:enumeration value="f"/>
          <xsd:enumeration value="true"/>
          <xsd:enumeration value="false"/>
          <xsd:enumeration value=""/>
          <xsd:enumeration value="True"/>
          <xsd:enumeration value="False"/>
        </xsd:restriction>
      </xsd:simpleType>
      <xsd:simpleType name="ST_UnsignedDecimalNumber">
        <xsd:restriction base="xsd:decimal">
          <xsd:minInclusive value="0"/>
        </xsd:restriction>
      </xsd:simpleType>
      <xsd:simpleType name="ST_TwipsMeasure">
        <xsd:union memberTypes="ST_UnsignedDecimalNumber ST_PositiveUniversalMeasure"/>
      </xsd:simpleType>
      <xsd:simpleType name="ST_VerticalAlignRun">
        <xsd:restriction base="xsd:string">
          <xsd:enumeration value="baseline"/>
          <xsd:enumeration value="superscript"/>
          <xsd:enumeration value="subscript"/>
        </xsd:restriction>
      </xsd:simpleType>
      <xsd:simpleType name="ST_Xstring">
        <xsd:restriction base="xsd:string"/>
      </xsd:simpleType>
      <xsd:simpleType name="ST_XAlign">
        <xsd:restriction base="xsd:string">
          <xsd:enumeration value="left"/>
          <xsd:enumeration value="center"/>
          <xsd:enumeration value="right"/>
          <xsd:enumeration value="inside"/>
          <xsd:enumeration value="outside"/>
        </xsd:restriction>
      </xsd:simpleType>
      <xsd:simpleType name="ST_YAlign">
        <xsd:restriction base="xsd:string">
          <xsd:enumeration value="inline"/>
          <xsd:enumeration value="top"/>
          <xsd:enumeration value="center"/>
          <xsd:enumeration value="bottom"/>
          <xsd:enumeration value="inside"/>
          <xsd:enumeration value="outside"/>
        </xsd:restriction>
      </xsd:simpleType>
      <xsd:simpleType name="ST_ConformanceClass">
        <xsd:restriction base="xsd:string">
          <xsd:enumeration value="strict"/>
          <xsd:enumeration value="transitional"/>
        </xsd:restriction>
      </xsd:simpleType>
      <xsd:simpleType name="ST_UniversalMeasure">
        <xsd:restriction base="xsd:string">
          <xsd:pattern value="-?[0-9]+(\.[0-9]+)?(mm|cm|in|pt|pc|pi)"/>
        </xsd:restriction>
      </xsd:simpleType>
      <xsd:simpleType name="ST_PositiveUniversalMeasure">
        <xsd:restriction base="ST_UniversalMeasure">
          <xsd:pattern value="[0-9]+(\.[0-9]+)?(mm|cm|in|pt|pc|pi)"/>
        </xsd:restriction>
      </xsd:simpleType>
      <xsd:simpleType name="ST_Percentage">
        <xsd:restriction base="xsd:string">
          <xsd:pattern value="-?[0-9]+(\.[0-9]+)?%"/>
        </xsd:restriction>
      </xsd:simpleType>
      <xsd:simpleType name="ST_FixedPercentage">
        <xsd:restriction base="ST_Percentage">
          <xsd:pattern value="-?((100)|([0-9][0-9]?))(\.[0-9][0-9]?)?%"/>
        </xsd:restriction>
      </xsd:simpleType>
      <xsd:simpleType name="ST_PositivePercentage">
        <xsd:restriction base="ST_Percentage">
          <xsd:pattern value="[0-9]+(\.[0-9]+)?%"/>
        </xsd:restriction>
      </xsd:simpleType>
      <xsd:simpleType name="ST_PositiveFixedPercentage">
        <xsd:restriction base="ST_Percentage">
          <xsd:pattern value="((100)|([0-9][0-9]?))(\.[0-9][0-9]?)?%"/>
        </xsd:restriction>
      </xsd:simpleType>
    </xsd:schema>
    
  • docx/ooxml/schemas/ISO-IEC29500-4_2016/shared-customXmlDataProperties.xsd1.2 KB2bddce292148upstream ↗
    <?xml version="1.0" encoding="utf-8"?>
    <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
      xmlns="http://schemas.openxmlformats.org/officeDocument/2006/customXml"
      xmlns:s="http://schemas.openxmlformats.org/officeDocument/2006/sharedTypes"
      targetNamespace="http://schemas.openxmlformats.org/officeDocument/2006/customXml"
      elementFormDefault="qualified" attributeFormDefault="qualified" blockDefault="#all">
      <xsd:import namespace="http://schemas.openxmlformats.org/officeDocument/2006/sharedTypes"
        schemaLocation="shared-commonSimpleTypes.xsd"/>
      <xsd:complexType name="CT_DatastoreSchemaRef">
        <xsd:attribute name="uri" type="xsd:string" use="required"/>
      </xsd:complexType>
      <xsd:complexType name="CT_DatastoreSchemaRefs">
        <xsd:sequence>
          <xsd:element name="schemaRef" type="CT_DatastoreSchemaRef" minOccurs="0" maxOccurs="unbounded"
          />
        </xsd:sequence>
      </xsd:complexType>
      <xsd:complexType name="CT_DatastoreItem">
        <xsd:sequence>
          <xsd:element name="schemaRefs" type="CT_DatastoreSchemaRefs" minOccurs="0"/>
        </xsd:sequence>
        <xsd:attribute name="itemID" type="s:ST_Guid" use="required"/>
      </xsd:complexType>
      <xsd:element name="datastoreItem" type="CT_DatastoreItem"/>
    </xsd:schema>
    
  • docx/ooxml/schemas/ISO-IEC29500-4_2016/shared-customXmlSchemaProperties.xsd880 B8a8c18ba2d5cupstream ↗
    <?xml version="1.0" encoding="utf-8"?>
    <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
      xmlns="http://schemas.openxmlformats.org/schemaLibrary/2006/main"
      targetNamespace="http://schemas.openxmlformats.org/schemaLibrary/2006/main"
      attributeFormDefault="qualified" elementFormDefault="qualified">
      <xsd:complexType name="CT_Schema">
        <xsd:attribute name="uri" type="xsd:string" default=""/>
        <xsd:attribute name="manifestLocation" type="xsd:string"/>
        <xsd:attribute name="schemaLocation" type="xsd:string"/>
        <xsd:attribute name="schemaLanguage" type="xsd:token"/>
      </xsd:complexType>
      <xsd:complexType name="CT_SchemaLibrary">
        <xsd:sequence>
          <xsd:element name="schema" type="CT_Schema" minOccurs="0" maxOccurs="unbounded"/>
        </xsd:sequence>
      </xsd:complexType>
      <xsd:element name="schemaLibrary" type="CT_SchemaLibrary"/>
    </xsd:schema>
    
  • docx/ooxml/schemas/ISO-IEC29500-4_2016/shared-documentPropertiesCustom.xsd2.5 KB5c42706a0d53upstream ↗
    <?xml version="1.0" encoding="utf-8"?>
    <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
      xmlns="http://schemas.openxmlformats.org/officeDocument/2006/custom-properties"
      xmlns:vt="http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes"
      xmlns:s="http://schemas.openxmlformats.org/officeDocument/2006/sharedTypes"
      targetNamespace="http://schemas.openxmlformats.org/officeDocument/2006/custom-properties"
      blockDefault="#all" elementFormDefault="qualified">
      <xsd:import namespace="http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes"
        schemaLocation="shared-documentPropertiesVariantTypes.xsd"/>
      <xsd:import namespace="http://schemas.openxmlformats.org/officeDocument/2006/sharedTypes"
        schemaLocation="shared-commonSimpleTypes.xsd"/>
      <xsd:element name="Properties" type="CT_Properties"/>
      <xsd:complexType name="CT_Properties">
        <xsd:sequence>
          <xsd:element name="property" minOccurs="0" maxOccurs="unbounded" type="CT_Property"/>
        </xsd:sequence>
      </xsd:complexType>
      <xsd:complexType name="CT_Property">
        <xsd:choice minOccurs="1" maxOccurs="1">
          <xsd:element ref="vt:vector"/>
          <xsd:element ref="vt:array"/>
          <xsd:element ref="vt:blob"/>
          <xsd:element ref="vt:oblob"/>
          <xsd:element ref="vt:empty"/>
          <xsd:element ref="vt:null"/>
          <xsd:element ref="vt:i1"/>
          <xsd:element ref="vt:i2"/>
          <xsd:element ref="vt:i4"/>
          <xsd:element ref="vt:i8"/>
          <xsd:element ref="vt:int"/>
          <xsd:element ref="vt:ui1"/>
          <xsd:element ref="vt:ui2"/>
          <xsd:element ref="vt:ui4"/>
          <xsd:element ref="vt:ui8"/>
          <xsd:element ref="vt:uint"/>
          <xsd:element ref="vt:r4"/>
          <xsd:element ref="vt:r8"/>
          <xsd:element ref="vt:decimal"/>
          <xsd:element ref="vt:lpstr"/>
          <xsd:element ref="vt:lpwstr"/>
          <xsd:element ref="vt:bstr"/>
          <xsd:element ref="vt:date"/>
          <xsd:element ref="vt:filetime"/>
          <xsd:element ref="vt:bool"/>
          <xsd:element ref="vt:cy"/>
          <xsd:element ref="vt:error"/>
          <xsd:element ref="vt:stream"/>
          <xsd:element ref="vt:ostream"/>
          <xsd:element ref="vt:storage"/>
          <xsd:element ref="vt:ostorage"/>
          <xsd:element ref="vt:vstream"/>
          <xsd:element ref="vt:clsid"/>
        </xsd:choice>
        <xsd:attribute name="fmtid" use="required" type="s:ST_Guid"/>
        <xsd:attribute name="pid" use="required" type="xsd:int"/>
        <xsd:attribute name="name" use="optional" type="xsd:string"/>
        <xsd:attribute name="linkTarget" use="optional" type="xsd:string"/>
      </xsd:complexType>
    </xsd:schema>
    
  • docx/ooxml/schemas/ISO-IEC29500-4_2016/shared-documentPropertiesExtended.xsd3.4 KB853c341c87feupstream ↗
    <?xml version="1.0" encoding="utf-8"?>
    <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
      xmlns="http://schemas.openxmlformats.org/officeDocument/2006/extended-properties"
      xmlns:vt="http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes"
      targetNamespace="http://schemas.openxmlformats.org/officeDocument/2006/extended-properties"
      elementFormDefault="qualified" blockDefault="#all">
      <xsd:import namespace="http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes"
        schemaLocation="shared-documentPropertiesVariantTypes.xsd"/>
      <xsd:element name="Properties" type="CT_Properties"/>
      <xsd:complexType name="CT_Properties">
        <xsd:all>
          <xsd:element name="Template" minOccurs="0" maxOccurs="1" type="xsd:string"/>
          <xsd:element name="Manager" minOccurs="0" maxOccurs="1" type="xsd:string"/>
          <xsd:element name="Company" minOccurs="0" maxOccurs="1" type="xsd:string"/>
          <xsd:element name="Pages" minOccurs="0" maxOccurs="1" type="xsd:int"/>
          <xsd:element name="Words" minOccurs="0" maxOccurs="1" type="xsd:int"/>
          <xsd:element name="Characters" minOccurs="0" maxOccurs="1" type="xsd:int"/>
          <xsd:element name="PresentationFormat" minOccurs="0" maxOccurs="1" type="xsd:string"/>
          <xsd:element name="Lines" minOccurs="0" maxOccurs="1" type="xsd:int"/>
          <xsd:element name="Paragraphs" minOccurs="0" maxOccurs="1" type="xsd:int"/>
          <xsd:element name="Slides" minOccurs="0" maxOccurs="1" type="xsd:int"/>
          <xsd:element name="Notes" minOccurs="0" maxOccurs="1" type="xsd:int"/>
          <xsd:element name="TotalTime" minOccurs="0" maxOccurs="1" type="xsd:int"/>
          <xsd:element name="HiddenSlides" minOccurs="0" maxOccurs="1" type="xsd:int"/>
          <xsd:element name="MMClips" minOccurs="0" maxOccurs="1" type="xsd:int"/>
          <xsd:element name="ScaleCrop" minOccurs="0" maxOccurs="1" type="xsd:boolean"/>
          <xsd:element name="HeadingPairs" minOccurs="0" maxOccurs="1" type="CT_VectorVariant"/>
          <xsd:element name="TitlesOfParts" minOccurs="0" maxOccurs="1" type="CT_VectorLpstr"/>
          <xsd:element name="LinksUpToDate" minOccurs="0" maxOccurs="1" type="xsd:boolean"/>
          <xsd:element name="CharactersWithSpaces" minOccurs="0" maxOccurs="1" type="xsd:int"/>
          <xsd:element name="SharedDoc" minOccurs="0" maxOccurs="1" type="xsd:boolean"/>
          <xsd:element name="HyperlinkBase" minOccurs="0" maxOccurs="1" type="xsd:string"/>
          <xsd:element name="HLinks" minOccurs="0" maxOccurs="1" type="CT_VectorVariant"/>
          <xsd:element name="HyperlinksChanged" minOccurs="0" maxOccurs="1" type="xsd:boolean"/>
          <xsd:element name="DigSig" minOccurs="0" maxOccurs="1" type="CT_DigSigBlob"/>
          <xsd:element name="Application" minOccurs="0" maxOccurs="1" type="xsd:string"/>
          <xsd:element name="AppVersion" minOccurs="0" maxOccurs="1" type="xsd:string"/>
          <xsd:element name="DocSecurity" minOccurs="0" maxOccurs="1" type="xsd:int"/>
        </xsd:all>
      </xsd:complexType>
      <xsd:complexType name="CT_VectorVariant">
        <xsd:sequence minOccurs="1" maxOccurs="1">
          <xsd:element ref="vt:vector"/>
        </xsd:sequence>
      </xsd:complexType>
      <xsd:complexType name="CT_VectorLpstr">
        <xsd:sequence minOccurs="1" maxOccurs="1">
          <xsd:element ref="vt:vector"/>
        </xsd:sequence>
      </xsd:complexType>
      <xsd:complexType name="CT_DigSigBlob">
        <xsd:sequence minOccurs="1" maxOccurs="1">
          <xsd:element ref="vt:blob"/>
        </xsd:sequence>
      </xsd:complexType>
    </xsd:schema>
    
  • docx/ooxml/schemas/ISO-IEC29500-4_2016/shared-documentPropertiesVariantTypes.xsd7.3 KBda835ee82d5cupstream ↗
    <?xml version="1.0" encoding="utf-8"?>
    <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
      xmlns="http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes"
      xmlns:s="http://schemas.openxmlformats.org/officeDocument/2006/sharedTypes"
      targetNamespace="http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes"
      blockDefault="#all" elementFormDefault="qualified">
      <xsd:import namespace="http://schemas.openxmlformats.org/officeDocument/2006/sharedTypes"
        schemaLocation="shared-commonSimpleTypes.xsd"/>
      <xsd:simpleType name="ST_VectorBaseType">
        <xsd:restriction base="xsd:string">
          <xsd:enumeration value="variant"/>
          <xsd:enumeration value="i1"/>
          <xsd:enumeration value="i2"/>
          <xsd:enumeration value="i4"/>
          <xsd:enumeration value="i8"/>
          <xsd:enumeration value="ui1"/>
          <xsd:enumeration value="ui2"/>
          <xsd:enumeration value="ui4"/>
          <xsd:enumeration value="ui8"/>
          <xsd:enumeration value="r4"/>
          <xsd:enumeration value="r8"/>
          <xsd:enumeration value="lpstr"/>
          <xsd:enumeration value="lpwstr"/>
          <xsd:enumeration value="bstr"/>
          <xsd:enumeration value="date"/>
          <xsd:enumeration value="filetime"/>
          <xsd:enumeration value="bool"/>
          <xsd:enumeration value="cy"/>
          <xsd:enumeration value="error"/>
          <xsd:enumeration value="clsid"/>
        </xsd:restriction>
      </xsd:simpleType>
      <xsd:simpleType name="ST_ArrayBaseType">
        <xsd:restriction base="xsd:string">
          <xsd:enumeration value="variant"/>
          <xsd:enumeration value="i1"/>
          <xsd:enumeration value="i2"/>
          <xsd:enumeration value="i4"/>
          <xsd:enumeration value="int"/>
          <xsd:enumeration value="ui1"/>
          <xsd:enumeration value="ui2"/>
          <xsd:enumeration value="ui4"/>
          <xsd:enumeration value="uint"/>
          <xsd:enumeration value="r4"/>
          <xsd:enumeration value="r8"/>
          <xsd:enumeration value="decimal"/>
          <xsd:enumeration value="bstr"/>
          <xsd:enumeration value="date"/>
          <xsd:enumeration value="bool"/>
          <xsd:enumeration value="cy"/>
          <xsd:enumeration value="error"/>
        </xsd:restriction>
      </xsd:simpleType>
      <xsd:simpleType name="ST_Cy">
        <xsd:restriction base="xsd:string">
          <xsd:pattern value="\s*[0-9]*\.[0-9]{4}\s*"/>
        </xsd:restriction>
      </xsd:simpleType>
      <xsd:simpleType name="ST_Error">
        <xsd:restriction base="xsd:string">
          <xsd:pattern value="\s*0x[0-9A-Za-z]{8}\s*"/>
        </xsd:restriction>
      </xsd:simpleType>
      <xsd:complexType name="CT_Empty"/>
      <xsd:complexType name="CT_Null"/>
      <xsd:complexType name="CT_Vector">
        <xsd:choice minOccurs="1" maxOccurs="unbounded">
          <xsd:element ref="variant"/>
          <xsd:element ref="i1"/>
          <xsd:element ref="i2"/>
          <xsd:element ref="i4"/>
          <xsd:element ref="i8"/>
          <xsd:element ref="ui1"/>
          <xsd:element ref="ui2"/>
          <xsd:element ref="ui4"/>
          <xsd:element ref="ui8"/>
          <xsd:element ref="r4"/>
          <xsd:element ref="r8"/>
          <xsd:element ref="lpstr"/>
          <xsd:element ref="lpwstr"/>
          <xsd:element ref="bstr"/>
          <xsd:element ref="date"/>
          <xsd:element ref="filetime"/>
          <xsd:element ref="bool"/>
          <xsd:element ref="cy"/>
          <xsd:element ref="error"/>
          <xsd:element ref="clsid"/>
        </xsd:choice>
        <xsd:attribute name="baseType" type="ST_VectorBaseType" use="required"/>
        <xsd:attribute name="size" type="xsd:unsignedInt" use="required"/>
      </xsd:complexType>
      <xsd:complexType name="CT_Array">
        <xsd:choice minOccurs="1" maxOccurs="unbounded">
          <xsd:element ref="variant"/>
          <xsd:element ref="i1"/>
          <xsd:element ref="i2"/>
          <xsd:element ref="i4"/>
          <xsd:element ref="int"/>
          <xsd:element ref="ui1"/>
          <xsd:element ref="ui2"/>
          <xsd:element ref="ui4"/>
          <xsd:element ref="uint"/>
          <xsd:element ref="r4"/>
          <xsd:element ref="r8"/>
          <xsd:element ref="decimal"/>
          <xsd:element ref="bstr"/>
          <xsd:element ref="date"/>
          <xsd:element ref="bool"/>
          <xsd:element ref="error"/>
          <xsd:element ref="cy"/>
        </xsd:choice>
        <xsd:attribute name="lBounds" type="xsd:int" use="required"/>
        <xsd:attribute name="uBounds" type="xsd:int" use="required"/>
        <xsd:attribute name="baseType" type="ST_ArrayBaseType" use="required"/>
      </xsd:complexType>
      <xsd:complexType name="CT_Variant">
        <xsd:choice minOccurs="1" maxOccurs="1">
          <xsd:element ref="variant"/>
          <xsd:element ref="vector"/>
          <xsd:element ref="array"/>
          <xsd:element ref="blob"/>
          <xsd:element ref="oblob"/>
          <xsd:element ref="empty"/>
          <xsd:element ref="null"/>
          <xsd:element ref="i1"/>
          <xsd:element ref="i2"/>
          <xsd:element ref="i4"/>
          <xsd:element ref="i8"/>
          <xsd:element ref="int"/>
          <xsd:element ref="ui1"/>
          <xsd:element ref="ui2"/>
          <xsd:element ref="ui4"/>
          <xsd:element ref="ui8"/>
          <xsd:element ref="uint"/>
          <xsd:element ref="r4"/>
          <xsd:element ref="r8"/>
          <xsd:element ref="decimal"/>
          <xsd:element ref="lpstr"/>
          <xsd:element ref="lpwstr"/>
          <xsd:element ref="bstr"/>
          <xsd:element ref="date"/>
          <xsd:element ref="filetime"/>
          <xsd:element ref="bool"/>
          <xsd:element ref="cy"/>
          <xsd:element ref="error"/>
          <xsd:element ref="stream"/>
          <xsd:element ref="ostream"/>
          <xsd:element ref="storage"/>
          <xsd:element ref="ostorage"/>
          <xsd:element ref="vstream"/>
          <xsd:element ref="clsid"/>
        </xsd:choice>
      </xsd:complexType>
      <xsd:complexType name="CT_Vstream">
        <xsd:simpleContent>
          <xsd:extension base="xsd:base64Binary">
            <xsd:attribute name="version" type="s:ST_Guid"/>
          </xsd:extension>
        </xsd:simpleContent>
      </xsd:complexType>
      <xsd:element name="variant" type="CT_Variant"/>
      <xsd:element name="vector" type="CT_Vector"/>
      <xsd:element name="array" type="CT_Array"/>
      <xsd:element name="blob" type="xsd:base64Binary"/>
      <xsd:element name="oblob" type="xsd:base64Binary"/>
      <xsd:element name="empty" type="CT_Empty"/>
      <xsd:element name="null" type="CT_Null"/>
      <xsd:element name="i1" type="xsd:byte"/>
      <xsd:element name="i2" type="xsd:short"/>
      <xsd:element name="i4" type="xsd:int"/>
      <xsd:element name="i8" type="xsd:long"/>
      <xsd:element name="int" type="xsd:int"/>
      <xsd:element name="ui1" type="xsd:unsignedByte"/>
      <xsd:element name="ui2" type="xsd:unsignedShort"/>
      <xsd:element name="ui4" type="xsd:unsignedInt"/>
      <xsd:element name="ui8" type="xsd:unsignedLong"/>
      <xsd:element name="uint" type="xsd:unsignedInt"/>
      <xsd:element name="r4" type="xsd:float"/>
      <xsd:element name="r8" type="xsd:double"/>
      <xsd:element name="decimal" type="xsd:decimal"/>
      <xsd:element name="lpstr" type="xsd:string"/>
      <xsd:element name="lpwstr" type="xsd:string"/>
      <xsd:element name="bstr" type="xsd:string"/>
      <xsd:element name="date" type="xsd:dateTime"/>
      <xsd:element name="filetime" type="xsd:dateTime"/>
      <xsd:element name="bool" type="xsd:boolean"/>
      <xsd:element name="cy" type="ST_Cy"/>
      <xsd:element name="error" type="ST_Error"/>
      <xsd:element name="stream" type="xsd:base64Binary"/>
      <xsd:element name="ostream" type="xsd:base64Binary"/>
      <xsd:element name="storage" type="xsd:base64Binary"/>
      <xsd:element name="ostorage" type="xsd:base64Binary"/>
      <xsd:element name="vstream" type="CT_Vstream"/>
      <xsd:element name="clsid" type="s:ST_Guid"/>
    </xsd:schema>
    
  • docx/ooxml/schemas/ISO-IEC29500-4_2016/shared-math.xsd23 KB87ad2658fa51upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • docx/ooxml/schemas/ISO-IEC29500-4_2016/shared-relationshipReference.xsd1.3 KB9e86f1b2be0dupstream ↗
    <?xml version="1.0" encoding="utf-8"?>
    <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
      xmlns="http://schemas.openxmlformats.org/officeDocument/2006/relationships"
      xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"
      elementFormDefault="qualified"
      targetNamespace="http://schemas.openxmlformats.org/officeDocument/2006/relationships"
      blockDefault="#all">
      <xsd:simpleType name="ST_RelationshipId">
        <xsd:restriction base="xsd:string"/>
      </xsd:simpleType>
      <xsd:attribute name="id" type="ST_RelationshipId"/>
      <xsd:attribute name="embed" type="ST_RelationshipId"/>
      <xsd:attribute name="link" type="ST_RelationshipId"/>
      <xsd:attribute name="dm" type="ST_RelationshipId" default=""/>
      <xsd:attribute name="lo" type="ST_RelationshipId" default=""/>
      <xsd:attribute name="qs" type="ST_RelationshipId" default=""/>
      <xsd:attribute name="cs" type="ST_RelationshipId" default=""/>
      <xsd:attribute name="blip" type="ST_RelationshipId" default=""/>
      <xsd:attribute name="pict" type="ST_RelationshipId"/>
      <xsd:attribute name="href" type="ST_RelationshipId"/>
      <xsd:attribute name="topLeft" type="ST_RelationshipId"/>
      <xsd:attribute name="topRight" type="ST_RelationshipId"/>
      <xsd:attribute name="bottomLeft" type="ST_RelationshipId"/>
      <xsd:attribute name="bottomRight" type="ST_RelationshipId"/>
    </xsd:schema>
    
  • docx/ooxml/schemas/ISO-IEC29500-4_2016/sml.xsd237 KBd0be42e757f3upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • docx/ooxml/schemas/ISO-IEC29500-4_2016/vml-main.xsd26 KB8821dd183cafupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • docx/ooxml/schemas/ISO-IEC29500-4_2016/vml-officeDrawing.xsd25 KBca2575c753beupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • docx/ooxml/schemas/ISO-IEC29500-4_2016/vml-presentationDrawing.xsd535 Bdd079e603f57upstream ↗
    <?xml version="1.0" encoding="utf-8"?>
    <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
      xmlns="urn:schemas-microsoft-com:office:powerpoint"
      targetNamespace="urn:schemas-microsoft-com:office:powerpoint" elementFormDefault="qualified"
      attributeFormDefault="unqualified">
      <xsd:element name="iscomment" type="CT_Empty"/>
      <xsd:element name="textdata" type="CT_Rel"/>
      <xsd:complexType name="CT_Empty"/>
      <xsd:complexType name="CT_Rel">
        <xsd:attribute name="id" type="xsd:string"/>
      </xsd:complexType>
    </xsd:schema>
    
  • docx/ooxml/schemas/ISO-IEC29500-4_2016/vml-spreadsheetDrawing.xsd5.6 KB3dd6cf625a74upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • docx/ooxml/schemas/ISO-IEC29500-4_2016/vml-wordprocessingDrawing.xsd3.9 KBf1041e34ef36upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • docx/ooxml/schemas/ISO-IEC29500-4_2016/wml.xsd167 KB9c5b7a633411upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • docx/ooxml/schemas/ISO-IEC29500-4_2016/xml.xsd4.5 KB0f13678d80a7upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • docx/ooxml/schemas/mce/mc.xsd3.1 KBef725457cf39upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • docx/ooxml/schemas/microsoft/wml-2010.xsd26 KBf65f777730d8upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • docx/ooxml/schemas/microsoft/wml-2012.xsd3.7 KB6b00755a9a87upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • docx/ooxml/schemas/microsoft/wml-2018.xsd901 Bf321d333a5e6upstream ↗
     <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:w12="http://schemas.openxmlformats.org/wordprocessingml/2006/main" elementFormDefault="qualified" attributeFormDefault="qualified" blockDefault="#all" xmlns="http://schemas.microsoft.com/office/word/2018/wordml" targetNamespace="http://schemas.microsoft.com/office/word/2018/wordml">
       <xsd:import id="w12" namespace="http://schemas.openxmlformats.org/wordprocessingml/2006/main" schemaLocation="../ISO-IEC29500-4_2016/wml.xsd"/>
       <xsd:complexType name="CT_Extension">
         <xsd:sequence>
           <xsd:any processContents="lax"/>
         </xsd:sequence>
         <xsd:attribute name="uri" type="xsd:token"/>
       </xsd:complexType>
       <xsd:complexType name="CT_ExtensionList">
         <xsd:sequence>
           <xsd:element name="ext" type="CT_Extension" minOccurs="0" maxOccurs="unbounded"/>
         </xsd:sequence>
       </xsd:complexType>
     </xsd:schema>
    
  • docx/ooxml/schemas/microsoft/wml-cex-2018.xsd1.7 KB364c6a9b8df6upstream ↗
     <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main" xmlns:s="http://schemas.openxmlformats.org/officeDocument/2006/sharedTypes" xmlns:w16="http://schemas.microsoft.com/office/word/2018/wordml" elementFormDefault="qualified" attributeFormDefault="qualified" blockDefault="#all" xmlns="http://schemas.microsoft.com/office/word/2018/wordml/cex" targetNamespace="http://schemas.microsoft.com/office/word/2018/wordml/cex">
       <xsd:import id="w16" namespace="http://schemas.microsoft.com/office/word/2018/wordml" schemaLocation="wml-2018.xsd"/>
       <xsd:import id="w" namespace="http://schemas.openxmlformats.org/wordprocessingml/2006/main" schemaLocation="../ISO-IEC29500-4_2016/wml.xsd"/>
       <xsd:import id="s" namespace="http://schemas.openxmlformats.org/officeDocument/2006/sharedTypes" schemaLocation="../ISO-IEC29500-4_2016/shared-commonSimpleTypes.xsd"/>
       <xsd:complexType name="CT_CommentsExtensible">
         <xsd:sequence>
           <xsd:element name="commentExtensible" type="CT_CommentExtensible" minOccurs="0" maxOccurs="unbounded"/>
           <xsd:element name="extLst" type="w16:CT_ExtensionList" minOccurs="0" maxOccurs="1"/>
         </xsd:sequence>
       </xsd:complexType>
       <xsd:complexType name="CT_CommentExtensible">
         <xsd:sequence>
           <xsd:element name="extLst" type="w16:CT_ExtensionList" minOccurs="0" maxOccurs="1"/>
         </xsd:sequence>
         <xsd:attribute name="durableId" type="w:ST_LongHexNumber" use="required"/>
         <xsd:attribute name="dateUtc" type="w:ST_DateTime" use="optional"/>
         <xsd:attribute name="intelligentPlaceholder" type="s:ST_OnOff" use="optional"/>
       </xsd:complexType>
       <xsd:element name="commentsExtensible" type="CT_CommentsExtensible"/>
     </xsd:schema>
    
  • docx/ooxml/schemas/microsoft/wml-cid-2016.xsd1002 Bfed9d15b7f50upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • docx/ooxml/schemas/microsoft/wml-sdtdatahash-2020.xsd600 B680cf15400cdupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • docx/ooxml/schemas/microsoft/wml-symex-2015.xsd745 B89ada90837b2upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • docx/ooxml/scripts/pack.py4.2 KB90e62253d93cupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • docx/ooxml/scripts/render.py2.2 KB8de7c9d85d3eupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • docx/ooxml/scripts/soffice.py4.0 KBe45fb428fb1bupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • docx/ooxml/scripts/unpack.py1.1 KBbc3768cefe4eupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • docx/ooxml/scripts/validate.py2.7 KB20ca9d771086upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • docx/ooxml/scripts/validation/__init__.py336 Bdb092ece7e21upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • docx/ooxml/scripts/validation/base.py41 KBa152016fda48upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • docx/ooxml/scripts/validation/docx.py9.8 KBf4575f9371b5upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • docx/ooxml/scripts/validation/pptx.py13 KBcf1e840295cbupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • docx/ooxml/scripts/validation/redlining.py7.1 KB7254c072d56cupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • docx/package-lock.json7.7 KBd13dc2ed04efupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • docx/package.json64 B223280c5c948upstream ↗
    {
      "private": true,
      "dependencies": {
        "docx": "^9"
      }
    }
    
  • README.mdupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

Plain-text copy, no login: /skill-bundles/appautomaton-document-skills-docx.md

// REPO STATS

184 stars
0 open issues
Last commit: 1mo ago