Skip to content

XSD Tools

Last Updated: May 2026 | Version: 1.10.0

Note (Phase 10c): The standalone XSD Editor tab has been retired. XSD editing — the Text/Tree/Graphic views, the inspector, the Type Library, type editing, documentation generation, schema flattening and schema analysis — now lives in the Unified Shell (open an .xsd file; "go to schema definition" from the XML editor opens the schema's graphic view at the element). The capabilities below are unchanged; they are reached through the shell rather than a dedicated sidebar tab.

This part of the application provides tools for working with XML Schemas (XSD). These tools help you understand, document, and use XSD files effectively.

Overview

When you open an .xsd file in the Unified Shell, the editor host and the Type Library activity provide several capabilities, each with a specific purpose:

Capability Description
Graphic View Visual schema editor with interactive tree
Type Library Browse and analyze all types in your schema
Type Editor Edit ComplexTypes and SimpleTypes graphically
Text View Raw XSD source code editor
Schema Analysis Statistics, constraints, validation, and quality checks
Documentation Generate HTML, Word, or PDF documentation
Preview Preview generated documentation
Generate Example Data Create sample XML from schema with customizable rules and profiles
Flatten Schema Merge includes into one file

1. Graphic View

The Graphic View lets you explore and edit your schemas visually.

XSD Graphic view in the Unified Shell An XSD open in the Unified Shell's Graphic view, with the Schema activity panel on the left

Features

  • Visual Tree: See your XSD as an interactive, hierarchical tree
  • Easy Navigation: Click on elements to explore their structure
  • Edit Documentation: Add or edit documentation for schema elements using the inline tab-based editor (no modal dialogs)
  • Add Examples: Include example values for elements
  • Drag & Drop: Reorganize elements by dragging them
  • Full Undo/Redo: Go back and forward through your changes

How to Use

  1. Open your XSD file in the editor host and switch to the Graphic view
  2. The schema appears as an interactive tree
  3. Select an element by clicking on it
  4. Edit properties in the panel on the right (name, type, cardinality/occurrence, use, form, constraints, documentation, and facets)
  5. Add children using the context menu (right-click)
  6. Drag elements to move them

Editing properties from any view (updated June 2026): The same Properties pane is now available in the Text view as well, not just the Graphic and Tree views. See Editing Schema Properties from Any View below.

Tips

  • Double-click an element to edit its name
  • Right-click for a context menu with common actions
  • Ctrl+Z to undo, Ctrl+Y to redo
  • Ctrl+S to save (a backup is created automatically)
  • The toolbar offers Save, Save As (save under a new name), and Save All buttons; since the XSD editor works on one schema at a time, Save All behaves the same as Save

2. Type Library

The Type Library provides a comprehensive view of all types defined in your schema.

Type Library in the Unified Shell The Schema activity's Type Library, with the schema diagram in the editor host

Features

Feature Description
All Types List View all SimpleTypes and ComplexTypes
Usage Information See XPath locations where each type is used
Unused Types Highlight types that are not referenced
Filter Options Filter by All, Simple, Complex, or Unused types
Search Find types by name
Documentation View documentation for each type
Export Export type list to file

How to Use

  1. Open your XSD file
  2. Open the Type Library activity from the activity bar
  3. Browse or search for types
  4. Click on a type to see its details
  5. Use the filter dropdown to narrow results

Filter Options

Filter Shows
All Types Every type in the schema
Simple Types Only xs:simpleType definitions
Complex Types Only xs:complexType definitions
Unused Types Types not referenced anywhere

3. Type Editor

The Type Editor provides dedicated editing for ComplexTypes and SimpleTypes.

Type Editor Type Editor with graphical editing for ComplexTypes

Features

Feature Description
Tab-Based Editing Each type opens in its own tab
ComplexType Editor Graphical editing with element tree
SimpleType Editor Form-based editing with facet panels
SimpleTypes List Overview of all SimpleTypes

ComplexType Editor

For ComplexTypes, you get a graphical editor similar to the main schema view:

  • Type name appears as the root node
  • Add, delete, modify elements graphically
  • Supports Sequence, Choice, and All compositors
  • Save/Discard with dirty tracking

SimpleType Editor

For SimpleTypes, you get a 5-panel form editor:

Panel Description
General Name and Final attribute
Restriction Base type and facets
List ItemType selection
Union MemberTypes management
Annotation Documentation and AppInfo

How to Use

  1. In the Type Library or Graphic View, find a type
  2. Double-click or right-click and select "Edit Type"
  3. The type opens in the Type Editor tab
  4. Make your changes
  5. Click Save or use Ctrl+S

4. Text View

The Text View provides raw XSD source code editing.

XSD Text view in the Unified Shell The XSD in the Unified Shell's Text view (Schema activity panel on the left, inspector on the right)

Screenshot note: Existing XSD Text view screenshots predate the editable Properties pane. The Properties pane now also appears alongside the Text view when the caret is inside a schema construct.

Features

  • Full Code Editor: View and edit the raw XSD source code
  • Syntax Highlighting: Color-coded code for easy reading
  • Search and Replace: Find and change text quickly
  • XPath/XQuery Panel: Query the schema with XPath
  • Save as Favorite: Quick access to frequently used schemas
  • Editable Properties pane: Move the text caret into a schema construct to select it and edit its properties without leaving the text editor (see below)

Editing Schema Properties from Any View

New in June 2026 - You can now edit a schema node's properties directly from the Text view, the same way you already could in the Tree and Graphic views.

The XSD editor has three views - Text, Tree, and Graphic - and all three share one in-memory schema model. The Properties pane works in every view:

  • Tree and Graphic views: Select a node to edit its name, type, cardinality/occurrence, use, form, constraints, documentation, and facets. (Unchanged.)
  • Text view: Move the text caret into an XSD construct - such as an xs:element, xs:complexType, xs:simpleType, xs:attribute, a compositor (xs:sequence, xs:choice, xs:all), or a facet - and the Properties pane selects the matching schema node and shows it editable. You get the same property editing as in the Tree and Graphic views, without leaving the source editor. Your edits round-trip back into the schema text as a minimal change that preserves your caret and scroll position.

If the caret is not inside a recognizable construct - for example inside an xs:annotation, a comment, or blank space - the pane falls back to a read-only caret/XPath view.

Because all three views share one model, your edits and your Undo/Redo history are preserved when you switch between Text, Tree, and Graphic.

What You Can Edit in the Properties Pane

New in June 2026 - The Properties pane gained app-info editing, multi-language documentation, comment editing, and constraint deletion.

For the selected schema node you can edit:

  • Name, type, cardinality/occurrence, use, form - The core properties of the node.
  • Facets - Add, edit, and remove facets such as patterns, enumerations, and length limits.
  • App info (xs:appinfo) - The machine-readable metadata attached to the node (for example the technical tags described in Documentation Generator).
  • Multi-language documentation (xs:documentation) - One row per language. Use Add language to add a translation and the ✕ button to remove one.
  • Comments - Select an XSD comment in the tree to edit its text. To add a comment, choose Add Comment… from a node's right-click context menu.
  • Constraints - In the CONSTRAINTS section, select a key, keyref, unique, or assert constraint and click Delete constraint to remove it.

Note: Structural editing (adding, deleting, and moving nodes) remains a Tree and Graphic capability via the right-click context menu. The Text view provides property editing through the Properties pane.

5. Schema Analysis

The Schema Analysis view (in the Type Library activity) provides comprehensive analysis tools for your XSD.

Schema statistics in the Unified Shell Schema statistics open as a report tab from the Schema activity's Statistics action

Sub-Tabs

The Schema Analysis view contains four sub-tabs:

Statistics

View schema metrics at a glance:

Metric Description
Element Count Total number of elements
Type Count Number of SimpleTypes and ComplexTypes
Attribute Count Total attributes defined
Group Count Model groups and attribute groups
Namespace Info Target namespace and prefixes
XSD Version 1.0 or 1.1 features detected

Identity Constraints

View and analyze identity constraints:

Constraint Type Description
xs:key Unique key definitions
xs:keyref Foreign key references
xs:unique Unique value constraints

For each constraint, you can see:

  • Selector XPath expression
  • Field XPath expressions
  • Referenced elements

XPath Validation

Test XPath expressions against sample XML:

  1. Load or generate sample XML
  2. Enter an XPath expression
  3. See matching nodes highlighted
  4. Validate constraints against real data

Quality Checks

Automated quality checks for your schema:

Check Description
Naming Conventions Consistent element/type naming
Documentation Coverage Percentage of documented elements
Unused Types Types defined but never used
Circular References Detect circular type references
Best Practices Common XSD best practices

6. Documentation Generator

Create professional documentation from your XSD file automatically.

Documentation Generator Generated HTML documentation from an XSD schema

Output Formats

Format Description
HTML Interactive web documentation with navigation
Word Microsoft Word (.docx) document
PDF PDF document using Apache FOP

How to Generate Documentation

  1. Open your XSD file in the editor host
  2. Open the Documentation view from the Type Library activity
  3. Select your output format (HTML, Word, or PDF)
  4. Choose diagram format (PNG or SVG)
  5. Configure options
  6. Click Generate
  7. Preview the documentation or open the folder

Generation Options

Option Description
Image Format Choose PNG or SVG for diagrams
Use Markdown Renderer Render Markdown formatting in documentation
Open file after creation Automatically open the generated file
Create example data if missing Generate sample values
Include type definitions Show type source code
Generate SVG overview page Interactive full-schema SVG

Language Settings

For multi-language schemas, you can:

  1. Click Scan Languages to detect available languages
  2. Select which languages to include
  3. Choose a fallback language for missing translations
  4. Use "Select All" or "Deselect All" for quick selection

Adding Technical Notes to Your Schema

You can add structured technical information directly in your XSD files:

Supported tags:

  • @since - When a feature was introduced
  • @see - References to other elements
  • @deprecated - Mark elements as deprecated
  • {@link /path/to/element} - Create clickable links

Example in your XSD:

<xs:element name="Transaction">
    <xs:annotation>
        <!-- User-friendly documentation -->
        <xs:documentation>
            Represents a single financial transaction.
        </xs:documentation>

        <!-- Technical notes for developers -->
        <xs:appinfo source="@since 4.0.0"/>
        <xs:appinfo source="@see {@link /FundsXML4/ControlData}"/>
        <xs:appinfo source="@deprecated Use NewTransaction instead."/>
    </xs:annotation>
</xs:element>

7. Sample XML Generator

Create sample XML files based on your XSD schema. This is useful for testing, data migration, or as a starting template.

Sample XML Generator Sample XML generator with rules table and XML preview

Unified Shell (June 2026): In the Unified Shell, sample-data generation lives in the Schema panel. It offers two actions: Generate Sample XML for the basic generation described below, and Generate Sample XML (Advanced)… for the rule-based, batch-capable generation. The screenshots above predate the advanced dialog.

Quick Start (Basic Generation)

For simple use cases, you can generate sample XML in seconds:

  1. Load your XSD file
  2. Open the Schema panel from the activity bar and click Generate Sample XML
  3. Choose your options:
    • Mandatory Only: Include only required elements
    • Max Occurrences: Limit repeating elements
  4. Click Generate
  5. Validate the generated XML against the schema
  6. Save or copy the generated XML

Profiled Generation (Advanced)

For more control, you can define rules that specify exactly how each element or attribute gets its value. Open it from Generate Sample XML (Advanced)… in the Schema panel. It includes:

Feature Description
XPath-Based Rules Set a generation strategy for each element or attribute by its XPath
11 Strategies Auto, Fixed Value, Omit, Empty, XSD Example, Enum Cycle, Sequence, XPath Reference, Random from List, Template, and Null
Auto-Fill XPaths Automatically extract all XPaths from your schema to populate the rules table
Saveable Profiles Save your generation configuration and reload it later
Profile Sharing Export and import profiles to share with colleagues
Batch Generation Generate multiple files at once with configurable file naming (for example, order_001.xml, order_002.xml)

For a complete guide with step-by-step instructions and examples, see Profiled XML Generation.

Validation

After generating sample XML, you can validate it:

  1. Click Validate XML
  2. See validation results in the panel
  3. Click on errors to see details
  4. Export errors to file if needed

8. XSD Flattener

Combine multiple XSD files into a single file. Useful when your schema imports other schemas.

XSD Flattener Flattener tool with before/after view

How to Use

  1. Select your main XSD file
  2. Choose where to save the new file
  3. Click Flatten
  4. The tool merges all <xs:include> schemas into one file

Preserving Includes and Imports

When saving schemas from the graphical editor, xs:include and xs:import declarations are preserved. The flattener only merges included content when you explicitly flatten — it does not alter your original schema structure.

When to Use

  • Distributing schemas to partners
  • Tools that don't support includes
  • Simplifying complex schema sets
  • Creating self-contained schemas

Supported XSD Features

Category Features
Elements Elements, Attributes, Groups
Types ComplexTypes, SimpleTypes
Compositors Sequence, Choice, All
Constraints Patterns, Enumerations, Length limits
References Import, Include, Redefine
XSD 1.1 Assertions, Alternatives, Open Content
Identity Key, KeyRef, Unique

Keyboard Shortcuts

Shortcut Action
Ctrl+S Save file
Ctrl+Z Undo
Ctrl+Y Redo
Ctrl+F Find/Replace
Ctrl+Q Toggle XPath panel
Ctrl+D Add to favorites
Delete Delete selected element
F2 Rename element
F5 Validate schema
Previous Home Next
XML Editor Features Home Profiled XML Generation

All Pages: Unified Shell | XML Editor | XML Features | JSON Editor | XSD Tools | Profiled XML Generation | XSD Validation | XSLT Viewer | XSLT Developer | FOP/PDF | Signatures | IntelliSense | Schematron | FundsXML Extensions | Favorites | Templates | Tech Stack | Security | Licenses