<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html lang="en-us" xml:lang="en-us">
<head>
<meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
<meta name="copyright" content="Copyright (c) 2000, 2006 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
<meta name="DC.rights.owner" content="(C) Copyright 2000, 2006" />
<meta content="public" name="security" />
<meta content="index,follow" name="Robots" />
<meta http-equiv="PICS-Label" content='(PICS-1.1 "http://www.icra.org/ratingsv02.html" l gen true r (cz 1 lz 1 nz 1 oz 1 vz 1) "http://www.rsac.org/ratingsv01.html" l gen true r (n 0 s 0 v 0 l 0) "http://www.classify.org/safesurf/" l gen true r (SS~~000 1))' />
<meta content="reference" name="DC.Type" />
<meta name="DC.Title" content="Editing XML documents with multiple namespaces" />
<meta name="abstract" content="You can use the XML schema any element to extend the content model of an XML document." />
<meta name="description" content="You can use the XML schema any element to extend the content model of an XML document." />
<meta content="XHTML" name="DC.Format" />
<meta content="rextctn" name="DC.Identifier" />
<meta content="en-us" name="DC.Language" />
<link href="../../org.eclipse.wst.doc.user/common.css" type="text/css" rel="stylesheet" />
<title>Editing XML documents with multiple namespaces</title>
</head>
<body id="rextctn"><a name="rextctn"><!-- --></a>


<h1 class="topictitle1">Editing XML documents with multiple namespaces</h1>



<div><p>You can use the XML schema <samp class="codeph">any</samp> element to extend
the content model of an XML document.</p>

<div class="section"><p>For example, you have an XML schema file called Book.xsd that
contains a complex type called BookType. BookType contains 4 elements (title,
author, year, and ISBN) and one  <samp class="codeph">any</samp> element. The namespace
for the <samp class="codeph">any</samp>  element is  <samp class="codeph">##any</samp>. This means
that in an instance document, you can insert any XML element to extend the
definition of the BookType.</p>
<p>You can also provide a more specific namespace.
For example, you have another schema called My_Book.xsd, which contains a
complex type called My_BookType. My_BookType contains 4 elements (title, author,
year, and ISBN) and one  <samp class="codeph">any</samp> element, but in this case the
namespace for the  BookType element is www.wesley.com. This means that in
an instance document, you can insert any XML element to extend the definition
of the BookType, provided that they belong to the namespace http://www.wesley.com.</p>
</div>

</div>

<div />

</body>
</html>