diff --git a/.claude/settings.local.json b/.claude/settings.local.json
index 323a2d1c..8cc22d5c 100644
--- a/.claude/settings.local.json
+++ b/.claude/settings.local.json
@@ -12,7 +12,10 @@
"Bash(dotnet run *)",
"Bash(DOTNET_MULTILEVEL_LOOKUP=0 dotnet exec \"LinqToXsd/bin/Debug/net7.0/LinqToXsd.dll\" gen \"LinqToXsd.Schemas/XInclude/xinclude.xsd\" -c \"LinqToXsd.Schemas/XInclude/xinclude.xsd.config\" -o \"LinqToXsd.Schemas/XInclude/xinclude.xsd-g.cs\")",
"Bash(echo \"EXIT: $?\")",
- "Bash(git stash *)"
+ "Bash(git stash *)",
+ "mcp__fuse__fuse_workspace",
+ "mcp__code-review-graph__get_minimal_context_tool",
+ "Bash(dotnet test *)"
]
},
"enableAllProjectMcpServers": true,
diff --git a/.gitignore b/.gitignore
index 3f800949..e7bea241 100644
--- a/.gitignore
+++ b/.gitignore
@@ -263,3 +263,4 @@ Samples/
*.diff
LinqToXsd.Schemas/_temp/
.fuse/
+*.DS_Store
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
new file mode 100644
index 00000000..f89ca882
--- /dev/null
+++ b/CONTRIBUTING.md
@@ -0,0 +1,41 @@
+# Contributing to LinqToXsdCore
+
+IMPORTANT BEFORE DOING ANY WORK: Please use the [LinqToXsd-TestingSuite.slnf](https://github.com/mamift/LinqToXsdCore/blob/testing/dublincore-xhtml/LinqToXsd-TestingSuite.slnf) solution filter file when working with this repo in Visual Studio or Rider. The full `sln` file has projects that currently do not build.
+
+Mandatory requirements before your PR is accepted or approved:
+
+1. **When contributing, please summarise your pull request in such a manner that it is acceptable to be included in the `RELEASENOTES.md` file** that is packaged in every nuget release (look at the release notes for previous releases to get an idea - be short but descriptive enough to point someone in the right direction if they want to dig deeper - this includes referring to Github issues and PRs).
+ - You do not have to update the `RELEASENOTES.md` file yourself but write a summary that's sufficient to be included there. This means that you should NOT GET OVERLY TECHNICAL IN YOUR PR DESCRIPTION. Please use [Github issues](https://github.com/mamift/LinqToXsdCore/issues) for that and refer to the issue in your PR description.
+
+2. **ENSURE THAT YOU WRITE A TEST FOR YOUR CHANGES.** Tests are incredibly helpful when collaborating with other developers - they help ensure that new contributions do not break existing functionality. Fixing a bug? Write a test to ensure the bug does not re-occur. Adding a feature? Add a test to cover the feature behavior or output.
+
+3. **ENSURE THAT YOUR CHANGES DO NOT BREAK EXISTING FUNCTIONALITY.** All tests should pass (including test written by you).
+ - There are some existing tests that are broken when run as part of the full suite, *but work when run individually* (`TestGenerateCodeFromSingleDirectoryWithAutoConfig` for instance) - these are acceptable failures.
+ - For tests that are broken and need updating, please annotate them such that they still run *but are not counted as failures or ignored* (see `TestGetFullPathFromSchemaInGraph`),
+ - Or that they need to be explicitly run by the user (see `PrototypeSplitByNamespaceAndClass`), so wil not run during the CI/DevOps builds.
+
+For points 2. and 3. the preferred type of test is an end to end code generation test; so this counts as an integration test. Unit tests should be preferred when testing extension methods.
+
+## Use of AI
+
+We welcome the use of AI in your pull requests, so long as you follow the above rules - remember NO TEST FAILURES. And if your PR brings in changes that results in test failures, then those failures need to be fixed before the PR can be approved. AI coding agents should help you with fixing these.
+
+Much of the code base and indeed most of the test suite pre-dates AI coding agents (the original Microsoft code was written in 2008-2011 and was ported to .NET Core/.NET Standard in 2019), so as long as the existing test suite passes, then new code, even if AI generated is acceptable.
+
+## Optional things
+
+- Please consider contributing the full XSD file that exhibits any code generation bugs. In terms of cyclomatic complexity, the code base rates incredibly high, and as a result, LinqToXsd emits a very specific output, and is highly vulnerable to regressions even over seemingly trivial code changes.
+
+ It also does not cover the entire W3C XML Schema v1.0 specification - so when a code gen bug is discovered, it is incredibly helpful to have the full XSD file as many parts of the XML Schema specification interact in quirky ways when transposing it to C#. Some things simply cannot be handled by LinqToXsd as there currently exists no idomatic way to model an XSD concept or construct in C#. Having the XSD on file helps when new C# language versions are released, and they can be evaluated for future implementation.
+ - In cases where bugs from specific XSD files are unfeasible to fix in a single PR, please:
+ - contribute the XSD file under it's own separate folder under the [GeneratedSchemaLibraries](https://github.com/mamift/LinqToXsdCore/tree/master/GeneratedSchemaLibraries) folder,
+ - then run the [create individual xsd libraries.ps1 PowerShell script](https://github.com/mamift/LinqToXsdCore/blob/testing/dublincore-xhtml/GeneratedSchemaLibraries/create%20individual%20xsd%20libraries.ps1) to automatically create a `.CSPROJ` file and link it to the greater solution.
+ - This allows storing the XSD for future bug fixing and also segregating buggy code out in it's own project so that the test project can still build and run. Uncompilable code **should not be linked to the test project ([XObjectTests](https://github.com/mamift/LinqToXsdCore/blob/master/XObjectsTests/XObjectsTests.csproj))**.
+
+- If the full XSD file cannot be given, then a minimal extract of the schema that exhibits the code generation bug is also acceptable. Many **code generation** tests simply make no sense unless there's an accompanying XSD file.
+
+- Another thing too: in the solution root there's a PowerShell script: [Regenerate-TestingSuite.ps1](https://github.com/mamift/LinqToXsdCore/blob/testing/dublincore-xhtml/Regenerate-TestingSuite.ps1). After all the tests in the testing project have been run (and pass), run this script to regenerate all C# code in the `GeneratedSchemaLibraries` folder. This is very helpful to catch regressions that are not covered in the test project. **Please try to fix any regressions alongside your PR! I WILL NOT APPROVE A PR THAT INTRODUCES A REGRESSION OR TEST FAILURE!** It is also helpful to have the changes in code generation captured in git from version to version to find and diagnose bugs, and to know which version may have changed ouptuts or behavior.
+ - Also: the script may generate new code files (i.e. not yet tracked in git - discard these files).
+ - *ONLY COMMIT CODE RE-GENERATED BY THE SCRIPT FOR EXISTING FILES THAT ARE TRACKED IN GIT.*
+
+Finally, the `AllEntCf.xsd-xml` schema is cursed; trying to run code gen on it will result in an out of memory error. I appreciate any efforts to get to the bottom of it. Please refrain from using this file in any tests. You have been warned.
\ No newline at end of file
diff --git a/GeneratedSchemaLibraries/Chem eStandards/OAGi_Chem_eStandards_5.3.xsd-g.cs b/GeneratedSchemaLibraries/Chem eStandards/OAGi_Chem_eStandards_5.3.xsd-g.cs
index a10ba09f..b197f0d8 100644
--- a/GeneratedSchemaLibraries/Chem eStandards/OAGi_Chem_eStandards_5.3.xsd-g.cs
+++ b/GeneratedSchemaLibraries/Chem eStandards/OAGi_Chem_eStandards_5.3.xsd-g.cs
@@ -15490,7 +15490,6 @@ private cidxListEnclosureTypeValidator() {
"Tin (Tinplate):Tin__Tinplate_",
"Stainless steel 1.4306 (V2A):Stainless_steel_1_4306__V2A_",
"Polyethylenetherephtalate (PET):Polyethylenetherephtalate__PET_",
- "Stainless Steel 1.4401:Stainless_Steel_1_4401",
"High-Purity Polymer:High_Purity_Polymer"}, 0, 0, null, null, 0, null, null, 0, null, 0, XmlSchemaWhiteSpace.Collapse));
}
diff --git a/GeneratedSchemaLibraries/DublinCore/dublincore.org_schemas_xmls_qdc_dc.xsd b/GeneratedSchemaLibraries/DublinCore/dublincore.org_schemas_xmls_qdc_dc.xsd
new file mode 100644
index 00000000..306a548f
--- /dev/null
+++ b/GeneratedSchemaLibraries/DublinCore/dublincore.org_schemas_xmls_qdc_dc.xsd
@@ -0,0 +1,119 @@
+
+
+
+
+
+ DCMES 1.1 XML Schema
+ XML Schema for http://purl.org/dc/elements/1.1/ namespace
+
+ Created 2008-02-11
+
+ Created by
+
+ Tim Cole (t-cole3@uiuc.edu)
+ Tom Habing (thabing@uiuc.edu)
+ Jane Hunter (jane@dstc.edu.au)
+ Pete Johnston (p.johnston@ukoln.ac.uk),
+ Carl Lagoze (lagoze@cs.cornell.edu)
+
+ This schema declares XML elements for the 15 DC elements from the
+ http://purl.org/dc/elements/1.1/ namespace.
+
+ It defines a complexType SimpleLiteral which permits mixed content
+ and makes the xml:lang attribute available. It disallows child elements by
+ use of minOcccurs/maxOccurs.
+
+ However, this complexType does permit the derivation of other complexTypes
+ which would permit child elements.
+
+ All elements are declared as substitutable for the abstract element any,
+ which means that the default type for all elements is dc:SimpleLiteral.
+
+
+
+
+
+
+
+
+
+
+
+
+ This is the default type for all of the DC elements.
+ It permits text content only with optional
+ xml:lang attribute.
+ Text is allowed because mixed="true", but sub-elements
+ are disallowed because minOccurs="0" and maxOccurs="0"
+ are on the xs:any tag.
+
+ This complexType allows for restriction or extension permitting
+ child elements.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ This group is included as a convenience for schema authors
+ who need to refer to all the elements in the
+ http://purl.org/dc/elements/1.1/ namespace.
+
+
+
+
+
+
+
+
+
+
+
+
+
+ This complexType is included as a convenience for schema authors who need to define a root
+ or container element for all of the DC elements.
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/GeneratedSchemaLibraries/DublinCore/dublincore.org_schemas_xmls_qdc_dc.xsd.config b/GeneratedSchemaLibraries/DublinCore/dublincore.org_schemas_xmls_qdc_dc.xsd.config
new file mode 100644
index 00000000..3d62d891
--- /dev/null
+++ b/GeneratedSchemaLibraries/DublinCore/dublincore.org_schemas_xmls_qdc_dc.xsd.config
@@ -0,0 +1,21 @@
+
+
+
+ false
+ false
+ false
+
+
+
+
+
+
+
+
+
+ false
+
+
+
+
+
\ No newline at end of file
diff --git a/GeneratedSchemaLibraries/DublinCore/dublincore.org_schemas_xmls_qdc_dc.xsd.cs b/GeneratedSchemaLibraries/DublinCore/dublincore.org_schemas_xmls_qdc_dc.xsd.cs
new file mode 100644
index 00000000..d5aeaaed
--- /dev/null
+++ b/GeneratedSchemaLibraries/DublinCore/dublincore.org_schemas_xmls_qdc_dc.xsd.cs
@@ -0,0 +1,3158 @@
+//------------------------------------------------------------------------------
+//
+// This code was generated by a tool.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+//------------------------------------------------------------------------------
+
+namespace W3C.XmlNs1 {
+ using System;
+ using System.Collections;
+ using System.Collections.Generic;
+ using System.ComponentModel;
+ using System.IO;
+ using System.Linq;
+ using System.Diagnostics;
+ using System.Xml;
+ using System.Xml.Schema;
+ using System.Xml.Linq;
+ using Xml.Schema.Linq;
+ using Purl.Dcmes.Elements;
+
+
+ public sealed class lang {
+
+ private lang() {
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ public static Xml.Schema.Linq.SimpleTypeValidator TypeDefinition = new Xml.Schema.Linq.UnionSimpleTypeValidator(XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.AnyAtomicType), null, new Xml.Schema.Linq.SimpleTypeValidator[] {
+ new Xml.Schema.Linq.AtomicSimpleTypeValidator(XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.Language), null),
+ new Xml.Schema.Linq.AtomicSimpleTypeValidator(XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String), new Xml.Schema.Linq.RestrictionFacets(((Xml.Schema.Linq.RestrictionFlags)(16)), new object[] {
+ ""}, 0, 0, null, null, 0, null, null, 0, null, 0, XmlSchemaWhiteSpace.Preserve))});
+ }
+}
+namespace Purl.Dcmes.Elements {
+ using System;
+ using System.Collections;
+ using System.Collections.Generic;
+ using System.ComponentModel;
+ using System.IO;
+ using System.Linq;
+ using System.Diagnostics;
+ using System.Xml;
+ using System.Xml.Schema;
+ using System.Xml.Linq;
+ using Xml.Schema.Linq;
+ using W3C.XmlNs1;
+
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public partial class SimpleLiteral : XTypedElement, IXMetaData {
+
+ public static explicit operator SimpleLiteral(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
+
+ public override XTypedElement Clone() {
+ return XTypedServices.CloneXTypedElement(this);
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public SimpleLiteral() {
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ internal static readonly System.Xml.Linq.XName langXName = System.Xml.Linq.XName.Get("lang", "http://www.w3.org/XML/1998/namespace");
+
+ ///
+ ///
+ /// Occurrence: optional
+ ///
+ ///
+ public virtual object lang {
+ get {
+ XAttribute x = this.Attribute(langXName);
+ return XTypedServices.ParseUnionValue(x, global::W3C.XmlNs1.lang.TypeDefinition);
+ }
+ set {
+ this.SetUnionAttribute(value, "lang", this, langXName, global::W3C.XmlNs1.lang.TypeDefinition);
+ }
+ }
+
+ private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("SimpleLiteral", "http://purl.org/dc/elements/1.1/");
+
+ ContentModelEntity IXMetaData.GetContentModel() {
+ return ContentModelEntity.Default;
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ System.Xml.Linq.XName IXMetaData.SchemaName {
+ get {
+ return xName;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ SchemaOrigin IXMetaData.TypeOrigin {
+ get {
+ return SchemaOrigin.Fragment;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ ILinqToXsdTypeManager IXMetaData.TypeManager {
+ get {
+ return LinqToXsdTypeManager.Instance;
+ }
+ }
+ }
+
+ ///
+ ///
+ ///
+ /// This complexType is included as a convenience for schema authors who need to define a root
+ /// or container element for all of the DC elements.
+ ///
+ ///
+ ///
+ /// Regular expression: (((any)*))
+ ///
+ ///
+ public partial class elementContainer : XTypedElement, IXMetaData {
+
+ public static explicit operator elementContainer(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
+
+ public override XTypedElement Clone() {
+ return XTypedServices.CloneXTypedElement(this);
+ }
+
+ ///
+ ///
+ ///
+ /// This complexType is included as a convenience for schema authors who need to define a root
+ /// or container element for all of the DC elements.
+ ///
+ ///
+ ///
+ /// Regular expression: (((any)*))
+ ///
+ ///
+ public elementContainer() {
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ internal static readonly System.Xml.Linq.XName anyXName = System.Xml.Linq.XName.Get("any", "http://purl.org/dc/elements/1.1/");
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ private XTypedSubstitutedList anyField;
+
+ ///
+ ///
+ /// Occurrence: required, choice
+ ///
+ ///
+ /// Setter: Appends
+ ///
+ ///
+ /// Substitution members: any, title, creator, subject, description, publisher, contributor, date, type, format, identifier, source, language, relation, coverage, rights
+ ///
+ ///
+ /// Regular expression: (((any)*))
+ ///
+ ///
+ public virtual IList any {
+ get {
+ if ((this.anyField == null)) {
+ this.anyField = new XTypedSubstitutedList(this, LinqToXsdTypeManager.Instance, System.Xml.Linq.XName.Get("any", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("title", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("creator", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("subject", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("description", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("publisher", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("contributor", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("date", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("type", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("format", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("identifier", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("source", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("language", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("relation", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("coverage", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("rights", "http://purl.org/dc/elements/1.1/"));
+ }
+ return this.anyField;
+ }
+ set {
+ if ((value == null)) {
+ this.anyField = null;
+ }
+ else {
+ if ((this.anyField == null)) {
+ this.anyField = XTypedSubstitutedList.Initialize(this, LinqToXsdTypeManager.Instance, value, System.Xml.Linq.XName.Get("any", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("title", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("creator", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("subject", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("description", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("publisher", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("contributor", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("date", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("type", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("format", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("identifier", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("source", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("language", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("relation", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("coverage", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("rights", "http://purl.org/dc/elements/1.1/"));
+ }
+ else {
+ XTypedServices.SetList(this.anyField, value);
+ }
+ }
+ }
+ }
+
+ private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("elementContainer", "http://purl.org/dc/elements/1.1/");
+
+ static elementContainer() {
+ BuildElementDictionary();
+ contentModel = new ChoiceContentModelEntity(new SequenceContentModelEntity(new ChoiceContentModelEntity(new SubstitutedContentModelEntity(System.Xml.Linq.XName.Get("any", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("title", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("creator", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("subject", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("description", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("publisher", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("contributor", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("date", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("type", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("format", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("identifier", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("source", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("language", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("relation", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("coverage", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("rights", "http://purl.org/dc/elements/1.1/")))));
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ private static Dictionary localElementDictionary = new Dictionary();
+
+ private static void BuildElementDictionary() {
+ localElementDictionary.Add(anyXName, typeof(any));
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ Dictionary IXMetaData.LocalElementsDictionary {
+ get {
+ return localElementDictionary;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ private static ContentModelEntity contentModel;
+
+ ContentModelEntity IXMetaData.GetContentModel() {
+ return contentModel;
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ System.Xml.Linq.XName IXMetaData.SchemaName {
+ get {
+ return xName;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ SchemaOrigin IXMetaData.TypeOrigin {
+ get {
+ return SchemaOrigin.Fragment;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ ILinqToXsdTypeManager IXMetaData.TypeManager {
+ get {
+ return LinqToXsdTypeManager.Instance;
+ }
+ }
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public abstract partial class any : XTypedElement, IXMetaData {
+
+ public void Save(string xmlFile) {
+ XTypedServices.Save(xmlFile, Untyped);
+ }
+
+ public void Save(System.IO.TextWriter tw) {
+ XTypedServices.Save(tw, Untyped);
+ }
+
+ public void Save(System.Xml.XmlWriter xmlWriter) {
+ XTypedServices.Save(xmlWriter, Untyped);
+ }
+
+ public static any Load(string xmlFile) {
+ return ((any)(XTypedServices.ToXTypedElement(XElement.Load(xmlFile), LinqToXsdTypeManager.Instance)));
+ }
+
+ public static any Load(System.IO.TextReader xmlFile) {
+ return ((any)(XTypedServices.ToXTypedElement(XElement.Load(xmlFile), LinqToXsdTypeManager.Instance)));
+ }
+
+ public static any Parse(string xml) {
+ return ((any)(XTypedServices.ToXTypedElement(XElement.Parse(xml), LinqToXsdTypeManager.Instance)));
+ }
+
+ public static explicit operator any(XElement xe) { return (any)XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
+
+ protected any(bool setNull) {
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ private SimpleLiteral ContentField;
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public any() {
+ SetInnerType(new SimpleLiteral());
+ }
+
+ public override XElement Untyped {
+ get {
+ return base.Untyped;
+ }
+ set {
+ base.Untyped = value;
+ if ((this.ContentField != null)) {
+ this.ContentField.Untyped = value;
+ }
+ }
+ }
+
+ public virtual SimpleLiteral Content {
+ get {
+ return ContentField;
+ }
+ }
+
+ private void SetInnerType(SimpleLiteral ContentField) {
+ this.ContentField = ((SimpleLiteral)(XTypedServices.GetCloneIfRooted(ContentField)));
+ XTypedServices.SetName(this, this.ContentField);
+ }
+
+ protected virtual void SetSubstitutionMember(SimpleLiteral ContentField) {
+ this.ContentField = ContentField;
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public any(SimpleLiteral content) {
+ SetInnerType(content);
+ }
+
+ ///
+ ///
+ /// Occurrence: optional
+ ///
+ ///
+ public virtual object lang {
+ get {
+ return this.ContentField.lang;
+ }
+ set {
+ this.ContentField.lang = value;
+ }
+ }
+
+ private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("any", "http://purl.org/dc/elements/1.1/");
+
+ Dictionary IXMetaData.LocalElementsDictionary {
+ get {
+ IXMetaData schemaMetaData = ((IXMetaData)(this.Content));
+ return schemaMetaData.LocalElementsDictionary;
+ }
+ }
+
+ XTypedElement IXMetaData.Content {
+ get {
+ return this.Content;
+ }
+ }
+
+ ContentModelEntity IXMetaData.GetContentModel() {
+ return ContentModelEntity.Default;
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ System.Xml.Linq.XName IXMetaData.SchemaName {
+ get {
+ return xName;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ SchemaOrigin IXMetaData.TypeOrigin {
+ get {
+ return SchemaOrigin.Element;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ ILinqToXsdTypeManager IXMetaData.TypeManager {
+ get {
+ return LinqToXsdTypeManager.Instance;
+ }
+ }
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public partial class title : global::Purl.Dcmes.Elements.any, IXMetaData {
+
+ public new static title Load(string xmlFile) {
+ return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance);
+ }
+
+ public static title Load(System.IO.TextReader xmlFile) {
+ return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance);
+ }
+
+ public new static title Parse(string xml) {
+ return XTypedServices.Parse(xml, LinqToXsdTypeManager.Instance);
+ }
+
+ public static explicit operator title(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
+
+ public override XTypedElement Clone() {
+ return new title(((SimpleLiteral)(this.Content.Clone())));
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ private SimpleLiteral ContentField;
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public title() :
+ base(true) {
+ SetInnerType(new SimpleLiteral());
+ }
+
+ public override XElement Untyped {
+ get {
+ return base.Untyped;
+ }
+ set {
+ base.Untyped = value;
+ this.ContentField.Untyped = value;
+ }
+ }
+
+ public new virtual SimpleLiteral Content {
+ get {
+ return ContentField;
+ }
+ }
+
+ private void SetInnerType(SimpleLiteral ContentField) {
+ this.ContentField = ((SimpleLiteral)(XTypedServices.GetCloneIfRooted(ContentField)));
+ XTypedServices.SetName(this, this.ContentField);
+ base.SetSubstitutionMember(ContentField);
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public title(SimpleLiteral content) :
+ base(true) {
+ SetInnerType(content);
+ }
+
+ private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("title", "http://purl.org/dc/elements/1.1/");
+
+ Dictionary IXMetaData.LocalElementsDictionary {
+ get {
+ IXMetaData schemaMetaData = ((IXMetaData)(this.Content));
+ return schemaMetaData.LocalElementsDictionary;
+ }
+ }
+
+ XTypedElement IXMetaData.Content {
+ get {
+ return this.Content;
+ }
+ }
+
+ ContentModelEntity IXMetaData.GetContentModel() {
+ return ContentModelEntity.Default;
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ System.Xml.Linq.XName IXMetaData.SchemaName {
+ get {
+ return xName;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ SchemaOrigin IXMetaData.TypeOrigin {
+ get {
+ return SchemaOrigin.Element;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ ILinqToXsdTypeManager IXMetaData.TypeManager {
+ get {
+ return LinqToXsdTypeManager.Instance;
+ }
+ }
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public partial class creator : global::Purl.Dcmes.Elements.any, IXMetaData {
+
+ public new static creator Load(string xmlFile) {
+ return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance);
+ }
+
+ public static creator Load(System.IO.TextReader xmlFile) {
+ return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance);
+ }
+
+ public new static creator Parse(string xml) {
+ return XTypedServices.Parse(xml, LinqToXsdTypeManager.Instance);
+ }
+
+ public static explicit operator creator(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
+
+ public override XTypedElement Clone() {
+ return new creator(((SimpleLiteral)(this.Content.Clone())));
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ private SimpleLiteral ContentField;
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public creator() :
+ base(true) {
+ SetInnerType(new SimpleLiteral());
+ }
+
+ public override XElement Untyped {
+ get {
+ return base.Untyped;
+ }
+ set {
+ base.Untyped = value;
+ this.ContentField.Untyped = value;
+ }
+ }
+
+ public new virtual SimpleLiteral Content {
+ get {
+ return ContentField;
+ }
+ }
+
+ private void SetInnerType(SimpleLiteral ContentField) {
+ this.ContentField = ((SimpleLiteral)(XTypedServices.GetCloneIfRooted(ContentField)));
+ XTypedServices.SetName(this, this.ContentField);
+ base.SetSubstitutionMember(ContentField);
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public creator(SimpleLiteral content) :
+ base(true) {
+ SetInnerType(content);
+ }
+
+ private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("creator", "http://purl.org/dc/elements/1.1/");
+
+ Dictionary IXMetaData.LocalElementsDictionary {
+ get {
+ IXMetaData schemaMetaData = ((IXMetaData)(this.Content));
+ return schemaMetaData.LocalElementsDictionary;
+ }
+ }
+
+ XTypedElement IXMetaData.Content {
+ get {
+ return this.Content;
+ }
+ }
+
+ ContentModelEntity IXMetaData.GetContentModel() {
+ return ContentModelEntity.Default;
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ System.Xml.Linq.XName IXMetaData.SchemaName {
+ get {
+ return xName;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ SchemaOrigin IXMetaData.TypeOrigin {
+ get {
+ return SchemaOrigin.Element;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ ILinqToXsdTypeManager IXMetaData.TypeManager {
+ get {
+ return LinqToXsdTypeManager.Instance;
+ }
+ }
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public partial class subject : global::Purl.Dcmes.Elements.any, IXMetaData {
+
+ public new static subject Load(string xmlFile) {
+ return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance);
+ }
+
+ public static subject Load(System.IO.TextReader xmlFile) {
+ return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance);
+ }
+
+ public new static subject Parse(string xml) {
+ return XTypedServices.Parse(xml, LinqToXsdTypeManager.Instance);
+ }
+
+ public static explicit operator subject(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
+
+ public override XTypedElement Clone() {
+ return new subject(((SimpleLiteral)(this.Content.Clone())));
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ private SimpleLiteral ContentField;
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public subject() :
+ base(true) {
+ SetInnerType(new SimpleLiteral());
+ }
+
+ public override XElement Untyped {
+ get {
+ return base.Untyped;
+ }
+ set {
+ base.Untyped = value;
+ this.ContentField.Untyped = value;
+ }
+ }
+
+ public new virtual SimpleLiteral Content {
+ get {
+ return ContentField;
+ }
+ }
+
+ private void SetInnerType(SimpleLiteral ContentField) {
+ this.ContentField = ((SimpleLiteral)(XTypedServices.GetCloneIfRooted(ContentField)));
+ XTypedServices.SetName(this, this.ContentField);
+ base.SetSubstitutionMember(ContentField);
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public subject(SimpleLiteral content) :
+ base(true) {
+ SetInnerType(content);
+ }
+
+ private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("subject", "http://purl.org/dc/elements/1.1/");
+
+ Dictionary IXMetaData.LocalElementsDictionary {
+ get {
+ IXMetaData schemaMetaData = ((IXMetaData)(this.Content));
+ return schemaMetaData.LocalElementsDictionary;
+ }
+ }
+
+ XTypedElement IXMetaData.Content {
+ get {
+ return this.Content;
+ }
+ }
+
+ ContentModelEntity IXMetaData.GetContentModel() {
+ return ContentModelEntity.Default;
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ System.Xml.Linq.XName IXMetaData.SchemaName {
+ get {
+ return xName;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ SchemaOrigin IXMetaData.TypeOrigin {
+ get {
+ return SchemaOrigin.Element;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ ILinqToXsdTypeManager IXMetaData.TypeManager {
+ get {
+ return LinqToXsdTypeManager.Instance;
+ }
+ }
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public partial class description : global::Purl.Dcmes.Elements.any, IXMetaData {
+
+ public new static description Load(string xmlFile) {
+ return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance);
+ }
+
+ public static description Load(System.IO.TextReader xmlFile) {
+ return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance);
+ }
+
+ public new static description Parse(string xml) {
+ return XTypedServices.Parse(xml, LinqToXsdTypeManager.Instance);
+ }
+
+ public static explicit operator description(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
+
+ public override XTypedElement Clone() {
+ return new description(((SimpleLiteral)(this.Content.Clone())));
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ private SimpleLiteral ContentField;
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public description() :
+ base(true) {
+ SetInnerType(new SimpleLiteral());
+ }
+
+ public override XElement Untyped {
+ get {
+ return base.Untyped;
+ }
+ set {
+ base.Untyped = value;
+ this.ContentField.Untyped = value;
+ }
+ }
+
+ public new virtual SimpleLiteral Content {
+ get {
+ return ContentField;
+ }
+ }
+
+ private void SetInnerType(SimpleLiteral ContentField) {
+ this.ContentField = ((SimpleLiteral)(XTypedServices.GetCloneIfRooted(ContentField)));
+ XTypedServices.SetName(this, this.ContentField);
+ base.SetSubstitutionMember(ContentField);
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public description(SimpleLiteral content) :
+ base(true) {
+ SetInnerType(content);
+ }
+
+ private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("description", "http://purl.org/dc/elements/1.1/");
+
+ Dictionary IXMetaData.LocalElementsDictionary {
+ get {
+ IXMetaData schemaMetaData = ((IXMetaData)(this.Content));
+ return schemaMetaData.LocalElementsDictionary;
+ }
+ }
+
+ XTypedElement IXMetaData.Content {
+ get {
+ return this.Content;
+ }
+ }
+
+ ContentModelEntity IXMetaData.GetContentModel() {
+ return ContentModelEntity.Default;
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ System.Xml.Linq.XName IXMetaData.SchemaName {
+ get {
+ return xName;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ SchemaOrigin IXMetaData.TypeOrigin {
+ get {
+ return SchemaOrigin.Element;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ ILinqToXsdTypeManager IXMetaData.TypeManager {
+ get {
+ return LinqToXsdTypeManager.Instance;
+ }
+ }
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public partial class publisher : global::Purl.Dcmes.Elements.any, IXMetaData {
+
+ public new static publisher Load(string xmlFile) {
+ return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance);
+ }
+
+ public static publisher Load(System.IO.TextReader xmlFile) {
+ return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance);
+ }
+
+ public new static publisher Parse(string xml) {
+ return XTypedServices.Parse(xml, LinqToXsdTypeManager.Instance);
+ }
+
+ public static explicit operator publisher(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
+
+ public override XTypedElement Clone() {
+ return new publisher(((SimpleLiteral)(this.Content.Clone())));
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ private SimpleLiteral ContentField;
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public publisher() :
+ base(true) {
+ SetInnerType(new SimpleLiteral());
+ }
+
+ public override XElement Untyped {
+ get {
+ return base.Untyped;
+ }
+ set {
+ base.Untyped = value;
+ this.ContentField.Untyped = value;
+ }
+ }
+
+ public new virtual SimpleLiteral Content {
+ get {
+ return ContentField;
+ }
+ }
+
+ private void SetInnerType(SimpleLiteral ContentField) {
+ this.ContentField = ((SimpleLiteral)(XTypedServices.GetCloneIfRooted(ContentField)));
+ XTypedServices.SetName(this, this.ContentField);
+ base.SetSubstitutionMember(ContentField);
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public publisher(SimpleLiteral content) :
+ base(true) {
+ SetInnerType(content);
+ }
+
+ private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("publisher", "http://purl.org/dc/elements/1.1/");
+
+ Dictionary IXMetaData.LocalElementsDictionary {
+ get {
+ IXMetaData schemaMetaData = ((IXMetaData)(this.Content));
+ return schemaMetaData.LocalElementsDictionary;
+ }
+ }
+
+ XTypedElement IXMetaData.Content {
+ get {
+ return this.Content;
+ }
+ }
+
+ ContentModelEntity IXMetaData.GetContentModel() {
+ return ContentModelEntity.Default;
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ System.Xml.Linq.XName IXMetaData.SchemaName {
+ get {
+ return xName;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ SchemaOrigin IXMetaData.TypeOrigin {
+ get {
+ return SchemaOrigin.Element;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ ILinqToXsdTypeManager IXMetaData.TypeManager {
+ get {
+ return LinqToXsdTypeManager.Instance;
+ }
+ }
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public partial class contributor : global::Purl.Dcmes.Elements.any, IXMetaData {
+
+ public new static contributor Load(string xmlFile) {
+ return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance);
+ }
+
+ public static contributor Load(System.IO.TextReader xmlFile) {
+ return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance);
+ }
+
+ public new static contributor Parse(string xml) {
+ return XTypedServices.Parse(xml, LinqToXsdTypeManager.Instance);
+ }
+
+ public static explicit operator contributor(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
+
+ public override XTypedElement Clone() {
+ return new contributor(((SimpleLiteral)(this.Content.Clone())));
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ private SimpleLiteral ContentField;
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public contributor() :
+ base(true) {
+ SetInnerType(new SimpleLiteral());
+ }
+
+ public override XElement Untyped {
+ get {
+ return base.Untyped;
+ }
+ set {
+ base.Untyped = value;
+ this.ContentField.Untyped = value;
+ }
+ }
+
+ public new virtual SimpleLiteral Content {
+ get {
+ return ContentField;
+ }
+ }
+
+ private void SetInnerType(SimpleLiteral ContentField) {
+ this.ContentField = ((SimpleLiteral)(XTypedServices.GetCloneIfRooted(ContentField)));
+ XTypedServices.SetName(this, this.ContentField);
+ base.SetSubstitutionMember(ContentField);
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public contributor(SimpleLiteral content) :
+ base(true) {
+ SetInnerType(content);
+ }
+
+ private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("contributor", "http://purl.org/dc/elements/1.1/");
+
+ Dictionary IXMetaData.LocalElementsDictionary {
+ get {
+ IXMetaData schemaMetaData = ((IXMetaData)(this.Content));
+ return schemaMetaData.LocalElementsDictionary;
+ }
+ }
+
+ XTypedElement IXMetaData.Content {
+ get {
+ return this.Content;
+ }
+ }
+
+ ContentModelEntity IXMetaData.GetContentModel() {
+ return ContentModelEntity.Default;
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ System.Xml.Linq.XName IXMetaData.SchemaName {
+ get {
+ return xName;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ SchemaOrigin IXMetaData.TypeOrigin {
+ get {
+ return SchemaOrigin.Element;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ ILinqToXsdTypeManager IXMetaData.TypeManager {
+ get {
+ return LinqToXsdTypeManager.Instance;
+ }
+ }
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public partial class date : global::Purl.Dcmes.Elements.any, IXMetaData {
+
+ public new static date Load(string xmlFile) {
+ return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance);
+ }
+
+ public static date Load(System.IO.TextReader xmlFile) {
+ return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance);
+ }
+
+ public new static date Parse(string xml) {
+ return XTypedServices.Parse(xml, LinqToXsdTypeManager.Instance);
+ }
+
+ public static explicit operator date(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
+
+ public override XTypedElement Clone() {
+ return new date(((SimpleLiteral)(this.Content.Clone())));
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ private SimpleLiteral ContentField;
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public date() :
+ base(true) {
+ SetInnerType(new SimpleLiteral());
+ }
+
+ public override XElement Untyped {
+ get {
+ return base.Untyped;
+ }
+ set {
+ base.Untyped = value;
+ this.ContentField.Untyped = value;
+ }
+ }
+
+ public new virtual SimpleLiteral Content {
+ get {
+ return ContentField;
+ }
+ }
+
+ private void SetInnerType(SimpleLiteral ContentField) {
+ this.ContentField = ((SimpleLiteral)(XTypedServices.GetCloneIfRooted(ContentField)));
+ XTypedServices.SetName(this, this.ContentField);
+ base.SetSubstitutionMember(ContentField);
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public date(SimpleLiteral content) :
+ base(true) {
+ SetInnerType(content);
+ }
+
+ private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("date", "http://purl.org/dc/elements/1.1/");
+
+ Dictionary IXMetaData.LocalElementsDictionary {
+ get {
+ IXMetaData schemaMetaData = ((IXMetaData)(this.Content));
+ return schemaMetaData.LocalElementsDictionary;
+ }
+ }
+
+ XTypedElement IXMetaData.Content {
+ get {
+ return this.Content;
+ }
+ }
+
+ ContentModelEntity IXMetaData.GetContentModel() {
+ return ContentModelEntity.Default;
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ System.Xml.Linq.XName IXMetaData.SchemaName {
+ get {
+ return xName;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ SchemaOrigin IXMetaData.TypeOrigin {
+ get {
+ return SchemaOrigin.Element;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ ILinqToXsdTypeManager IXMetaData.TypeManager {
+ get {
+ return LinqToXsdTypeManager.Instance;
+ }
+ }
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public partial class type : global::Purl.Dcmes.Elements.any, IXMetaData {
+
+ public new static type Load(string xmlFile) {
+ return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance);
+ }
+
+ public static type Load(System.IO.TextReader xmlFile) {
+ return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance);
+ }
+
+ public new static type Parse(string xml) {
+ return XTypedServices.Parse(xml, LinqToXsdTypeManager.Instance);
+ }
+
+ public static explicit operator type(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
+
+ public override XTypedElement Clone() {
+ return new type(((SimpleLiteral)(this.Content.Clone())));
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ private SimpleLiteral ContentField;
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public type() :
+ base(true) {
+ SetInnerType(new SimpleLiteral());
+ }
+
+ public override XElement Untyped {
+ get {
+ return base.Untyped;
+ }
+ set {
+ base.Untyped = value;
+ this.ContentField.Untyped = value;
+ }
+ }
+
+ public new virtual SimpleLiteral Content {
+ get {
+ return ContentField;
+ }
+ }
+
+ private void SetInnerType(SimpleLiteral ContentField) {
+ this.ContentField = ((SimpleLiteral)(XTypedServices.GetCloneIfRooted(ContentField)));
+ XTypedServices.SetName(this, this.ContentField);
+ base.SetSubstitutionMember(ContentField);
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public type(SimpleLiteral content) :
+ base(true) {
+ SetInnerType(content);
+ }
+
+ private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("type", "http://purl.org/dc/elements/1.1/");
+
+ Dictionary IXMetaData.LocalElementsDictionary {
+ get {
+ IXMetaData schemaMetaData = ((IXMetaData)(this.Content));
+ return schemaMetaData.LocalElementsDictionary;
+ }
+ }
+
+ XTypedElement IXMetaData.Content {
+ get {
+ return this.Content;
+ }
+ }
+
+ ContentModelEntity IXMetaData.GetContentModel() {
+ return ContentModelEntity.Default;
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ System.Xml.Linq.XName IXMetaData.SchemaName {
+ get {
+ return xName;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ SchemaOrigin IXMetaData.TypeOrigin {
+ get {
+ return SchemaOrigin.Element;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ ILinqToXsdTypeManager IXMetaData.TypeManager {
+ get {
+ return LinqToXsdTypeManager.Instance;
+ }
+ }
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public partial class format : global::Purl.Dcmes.Elements.any, IXMetaData {
+
+ public new static format Load(string xmlFile) {
+ return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance);
+ }
+
+ public static format Load(System.IO.TextReader xmlFile) {
+ return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance);
+ }
+
+ public new static format Parse(string xml) {
+ return XTypedServices.Parse(xml, LinqToXsdTypeManager.Instance);
+ }
+
+ public static explicit operator format(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
+
+ public override XTypedElement Clone() {
+ return new format(((SimpleLiteral)(this.Content.Clone())));
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ private SimpleLiteral ContentField;
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public format() :
+ base(true) {
+ SetInnerType(new SimpleLiteral());
+ }
+
+ public override XElement Untyped {
+ get {
+ return base.Untyped;
+ }
+ set {
+ base.Untyped = value;
+ this.ContentField.Untyped = value;
+ }
+ }
+
+ public new virtual SimpleLiteral Content {
+ get {
+ return ContentField;
+ }
+ }
+
+ private void SetInnerType(SimpleLiteral ContentField) {
+ this.ContentField = ((SimpleLiteral)(XTypedServices.GetCloneIfRooted(ContentField)));
+ XTypedServices.SetName(this, this.ContentField);
+ base.SetSubstitutionMember(ContentField);
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public format(SimpleLiteral content) :
+ base(true) {
+ SetInnerType(content);
+ }
+
+ private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("format", "http://purl.org/dc/elements/1.1/");
+
+ Dictionary IXMetaData.LocalElementsDictionary {
+ get {
+ IXMetaData schemaMetaData = ((IXMetaData)(this.Content));
+ return schemaMetaData.LocalElementsDictionary;
+ }
+ }
+
+ XTypedElement IXMetaData.Content {
+ get {
+ return this.Content;
+ }
+ }
+
+ ContentModelEntity IXMetaData.GetContentModel() {
+ return ContentModelEntity.Default;
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ System.Xml.Linq.XName IXMetaData.SchemaName {
+ get {
+ return xName;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ SchemaOrigin IXMetaData.TypeOrigin {
+ get {
+ return SchemaOrigin.Element;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ ILinqToXsdTypeManager IXMetaData.TypeManager {
+ get {
+ return LinqToXsdTypeManager.Instance;
+ }
+ }
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public partial class identifier : global::Purl.Dcmes.Elements.any, IXMetaData {
+
+ public new static identifier Load(string xmlFile) {
+ return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance);
+ }
+
+ public static identifier Load(System.IO.TextReader xmlFile) {
+ return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance);
+ }
+
+ public new static identifier Parse(string xml) {
+ return XTypedServices.Parse(xml, LinqToXsdTypeManager.Instance);
+ }
+
+ public static explicit operator identifier(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
+
+ public override XTypedElement Clone() {
+ return new identifier(((SimpleLiteral)(this.Content.Clone())));
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ private SimpleLiteral ContentField;
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public identifier() :
+ base(true) {
+ SetInnerType(new SimpleLiteral());
+ }
+
+ public override XElement Untyped {
+ get {
+ return base.Untyped;
+ }
+ set {
+ base.Untyped = value;
+ this.ContentField.Untyped = value;
+ }
+ }
+
+ public new virtual SimpleLiteral Content {
+ get {
+ return ContentField;
+ }
+ }
+
+ private void SetInnerType(SimpleLiteral ContentField) {
+ this.ContentField = ((SimpleLiteral)(XTypedServices.GetCloneIfRooted(ContentField)));
+ XTypedServices.SetName(this, this.ContentField);
+ base.SetSubstitutionMember(ContentField);
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public identifier(SimpleLiteral content) :
+ base(true) {
+ SetInnerType(content);
+ }
+
+ private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("identifier", "http://purl.org/dc/elements/1.1/");
+
+ Dictionary IXMetaData.LocalElementsDictionary {
+ get {
+ IXMetaData schemaMetaData = ((IXMetaData)(this.Content));
+ return schemaMetaData.LocalElementsDictionary;
+ }
+ }
+
+ XTypedElement IXMetaData.Content {
+ get {
+ return this.Content;
+ }
+ }
+
+ ContentModelEntity IXMetaData.GetContentModel() {
+ return ContentModelEntity.Default;
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ System.Xml.Linq.XName IXMetaData.SchemaName {
+ get {
+ return xName;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ SchemaOrigin IXMetaData.TypeOrigin {
+ get {
+ return SchemaOrigin.Element;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ ILinqToXsdTypeManager IXMetaData.TypeManager {
+ get {
+ return LinqToXsdTypeManager.Instance;
+ }
+ }
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public partial class source : global::Purl.Dcmes.Elements.any, IXMetaData {
+
+ public new static source Load(string xmlFile) {
+ return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance);
+ }
+
+ public static source Load(System.IO.TextReader xmlFile) {
+ return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance);
+ }
+
+ public new static source Parse(string xml) {
+ return XTypedServices.Parse(xml, LinqToXsdTypeManager.Instance);
+ }
+
+ public static explicit operator source(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
+
+ public override XTypedElement Clone() {
+ return new source(((SimpleLiteral)(this.Content.Clone())));
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ private SimpleLiteral ContentField;
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public source() :
+ base(true) {
+ SetInnerType(new SimpleLiteral());
+ }
+
+ public override XElement Untyped {
+ get {
+ return base.Untyped;
+ }
+ set {
+ base.Untyped = value;
+ this.ContentField.Untyped = value;
+ }
+ }
+
+ public new virtual SimpleLiteral Content {
+ get {
+ return ContentField;
+ }
+ }
+
+ private void SetInnerType(SimpleLiteral ContentField) {
+ this.ContentField = ((SimpleLiteral)(XTypedServices.GetCloneIfRooted(ContentField)));
+ XTypedServices.SetName(this, this.ContentField);
+ base.SetSubstitutionMember(ContentField);
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public source(SimpleLiteral content) :
+ base(true) {
+ SetInnerType(content);
+ }
+
+ private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("source", "http://purl.org/dc/elements/1.1/");
+
+ Dictionary IXMetaData.LocalElementsDictionary {
+ get {
+ IXMetaData schemaMetaData = ((IXMetaData)(this.Content));
+ return schemaMetaData.LocalElementsDictionary;
+ }
+ }
+
+ XTypedElement IXMetaData.Content {
+ get {
+ return this.Content;
+ }
+ }
+
+ ContentModelEntity IXMetaData.GetContentModel() {
+ return ContentModelEntity.Default;
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ System.Xml.Linq.XName IXMetaData.SchemaName {
+ get {
+ return xName;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ SchemaOrigin IXMetaData.TypeOrigin {
+ get {
+ return SchemaOrigin.Element;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ ILinqToXsdTypeManager IXMetaData.TypeManager {
+ get {
+ return LinqToXsdTypeManager.Instance;
+ }
+ }
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public partial class language : global::Purl.Dcmes.Elements.any, IXMetaData {
+
+ public new static language Load(string xmlFile) {
+ return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance);
+ }
+
+ public static language Load(System.IO.TextReader xmlFile) {
+ return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance);
+ }
+
+ public new static language Parse(string xml) {
+ return XTypedServices.Parse(xml, LinqToXsdTypeManager.Instance);
+ }
+
+ public static explicit operator language(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
+
+ public override XTypedElement Clone() {
+ return new language(((SimpleLiteral)(this.Content.Clone())));
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ private SimpleLiteral ContentField;
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public language() :
+ base(true) {
+ SetInnerType(new SimpleLiteral());
+ }
+
+ public override XElement Untyped {
+ get {
+ return base.Untyped;
+ }
+ set {
+ base.Untyped = value;
+ this.ContentField.Untyped = value;
+ }
+ }
+
+ public new virtual SimpleLiteral Content {
+ get {
+ return ContentField;
+ }
+ }
+
+ private void SetInnerType(SimpleLiteral ContentField) {
+ this.ContentField = ((SimpleLiteral)(XTypedServices.GetCloneIfRooted(ContentField)));
+ XTypedServices.SetName(this, this.ContentField);
+ base.SetSubstitutionMember(ContentField);
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public language(SimpleLiteral content) :
+ base(true) {
+ SetInnerType(content);
+ }
+
+ private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("language", "http://purl.org/dc/elements/1.1/");
+
+ Dictionary IXMetaData.LocalElementsDictionary {
+ get {
+ IXMetaData schemaMetaData = ((IXMetaData)(this.Content));
+ return schemaMetaData.LocalElementsDictionary;
+ }
+ }
+
+ XTypedElement IXMetaData.Content {
+ get {
+ return this.Content;
+ }
+ }
+
+ ContentModelEntity IXMetaData.GetContentModel() {
+ return ContentModelEntity.Default;
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ System.Xml.Linq.XName IXMetaData.SchemaName {
+ get {
+ return xName;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ SchemaOrigin IXMetaData.TypeOrigin {
+ get {
+ return SchemaOrigin.Element;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ ILinqToXsdTypeManager IXMetaData.TypeManager {
+ get {
+ return LinqToXsdTypeManager.Instance;
+ }
+ }
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public partial class relation : global::Purl.Dcmes.Elements.any, IXMetaData {
+
+ public new static relation Load(string xmlFile) {
+ return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance);
+ }
+
+ public static relation Load(System.IO.TextReader xmlFile) {
+ return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance);
+ }
+
+ public new static relation Parse(string xml) {
+ return XTypedServices.Parse(xml, LinqToXsdTypeManager.Instance);
+ }
+
+ public static explicit operator relation(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
+
+ public override XTypedElement Clone() {
+ return new relation(((SimpleLiteral)(this.Content.Clone())));
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ private SimpleLiteral ContentField;
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public relation() :
+ base(true) {
+ SetInnerType(new SimpleLiteral());
+ }
+
+ public override XElement Untyped {
+ get {
+ return base.Untyped;
+ }
+ set {
+ base.Untyped = value;
+ this.ContentField.Untyped = value;
+ }
+ }
+
+ public new virtual SimpleLiteral Content {
+ get {
+ return ContentField;
+ }
+ }
+
+ private void SetInnerType(SimpleLiteral ContentField) {
+ this.ContentField = ((SimpleLiteral)(XTypedServices.GetCloneIfRooted(ContentField)));
+ XTypedServices.SetName(this, this.ContentField);
+ base.SetSubstitutionMember(ContentField);
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public relation(SimpleLiteral content) :
+ base(true) {
+ SetInnerType(content);
+ }
+
+ private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("relation", "http://purl.org/dc/elements/1.1/");
+
+ Dictionary IXMetaData.LocalElementsDictionary {
+ get {
+ IXMetaData schemaMetaData = ((IXMetaData)(this.Content));
+ return schemaMetaData.LocalElementsDictionary;
+ }
+ }
+
+ XTypedElement IXMetaData.Content {
+ get {
+ return this.Content;
+ }
+ }
+
+ ContentModelEntity IXMetaData.GetContentModel() {
+ return ContentModelEntity.Default;
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ System.Xml.Linq.XName IXMetaData.SchemaName {
+ get {
+ return xName;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ SchemaOrigin IXMetaData.TypeOrigin {
+ get {
+ return SchemaOrigin.Element;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ ILinqToXsdTypeManager IXMetaData.TypeManager {
+ get {
+ return LinqToXsdTypeManager.Instance;
+ }
+ }
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public partial class coverage : global::Purl.Dcmes.Elements.any, IXMetaData {
+
+ public new static coverage Load(string xmlFile) {
+ return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance);
+ }
+
+ public static coverage Load(System.IO.TextReader xmlFile) {
+ return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance);
+ }
+
+ public new static coverage Parse(string xml) {
+ return XTypedServices.Parse(xml, LinqToXsdTypeManager.Instance);
+ }
+
+ public static explicit operator coverage(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
+
+ public override XTypedElement Clone() {
+ return new coverage(((SimpleLiteral)(this.Content.Clone())));
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ private SimpleLiteral ContentField;
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public coverage() :
+ base(true) {
+ SetInnerType(new SimpleLiteral());
+ }
+
+ public override XElement Untyped {
+ get {
+ return base.Untyped;
+ }
+ set {
+ base.Untyped = value;
+ this.ContentField.Untyped = value;
+ }
+ }
+
+ public new virtual SimpleLiteral Content {
+ get {
+ return ContentField;
+ }
+ }
+
+ private void SetInnerType(SimpleLiteral ContentField) {
+ this.ContentField = ((SimpleLiteral)(XTypedServices.GetCloneIfRooted(ContentField)));
+ XTypedServices.SetName(this, this.ContentField);
+ base.SetSubstitutionMember(ContentField);
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public coverage(SimpleLiteral content) :
+ base(true) {
+ SetInnerType(content);
+ }
+
+ private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("coverage", "http://purl.org/dc/elements/1.1/");
+
+ Dictionary IXMetaData.LocalElementsDictionary {
+ get {
+ IXMetaData schemaMetaData = ((IXMetaData)(this.Content));
+ return schemaMetaData.LocalElementsDictionary;
+ }
+ }
+
+ XTypedElement IXMetaData.Content {
+ get {
+ return this.Content;
+ }
+ }
+
+ ContentModelEntity IXMetaData.GetContentModel() {
+ return ContentModelEntity.Default;
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ System.Xml.Linq.XName IXMetaData.SchemaName {
+ get {
+ return xName;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ SchemaOrigin IXMetaData.TypeOrigin {
+ get {
+ return SchemaOrigin.Element;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ ILinqToXsdTypeManager IXMetaData.TypeManager {
+ get {
+ return LinqToXsdTypeManager.Instance;
+ }
+ }
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public partial class rights : global::Purl.Dcmes.Elements.any, IXMetaData {
+
+ public new static rights Load(string xmlFile) {
+ return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance);
+ }
+
+ public static rights Load(System.IO.TextReader xmlFile) {
+ return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance);
+ }
+
+ public new static rights Parse(string xml) {
+ return XTypedServices.Parse(xml, LinqToXsdTypeManager.Instance);
+ }
+
+ public static explicit operator rights(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
+
+ public override XTypedElement Clone() {
+ return new rights(((SimpleLiteral)(this.Content.Clone())));
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ private SimpleLiteral ContentField;
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public rights() :
+ base(true) {
+ SetInnerType(new SimpleLiteral());
+ }
+
+ public override XElement Untyped {
+ get {
+ return base.Untyped;
+ }
+ set {
+ base.Untyped = value;
+ this.ContentField.Untyped = value;
+ }
+ }
+
+ public new virtual SimpleLiteral Content {
+ get {
+ return ContentField;
+ }
+ }
+
+ private void SetInnerType(SimpleLiteral ContentField) {
+ this.ContentField = ((SimpleLiteral)(XTypedServices.GetCloneIfRooted(ContentField)));
+ XTypedServices.SetName(this, this.ContentField);
+ base.SetSubstitutionMember(ContentField);
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public rights(SimpleLiteral content) :
+ base(true) {
+ SetInnerType(content);
+ }
+
+ private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("rights", "http://purl.org/dc/elements/1.1/");
+
+ Dictionary IXMetaData.LocalElementsDictionary {
+ get {
+ IXMetaData schemaMetaData = ((IXMetaData)(this.Content));
+ return schemaMetaData.LocalElementsDictionary;
+ }
+ }
+
+ XTypedElement IXMetaData.Content {
+ get {
+ return this.Content;
+ }
+ }
+
+ ContentModelEntity IXMetaData.GetContentModel() {
+ return ContentModelEntity.Default;
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ System.Xml.Linq.XName IXMetaData.SchemaName {
+ get {
+ return xName;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ SchemaOrigin IXMetaData.TypeOrigin {
+ get {
+ return SchemaOrigin.Element;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ ILinqToXsdTypeManager IXMetaData.TypeManager {
+ get {
+ return LinqToXsdTypeManager.Instance;
+ }
+ }
+ }
+
+ public class LinqToXsdTypeManager : ILinqToXsdTypeManager {
+
+ private LinqToXsdTypeManager() {
+ }
+
+ private static Dictionary typeDictionary = new Dictionary();
+
+ private static void BuildTypeDictionary() {
+ typeDictionary.Add(System.Xml.Linq.XName.Get("SimpleLiteral", "http://purl.org/dc/elements/1.1/"), typeof(global::Purl.Dcmes.Elements.SimpleLiteral));
+ typeDictionary.Add(System.Xml.Linq.XName.Get("elementContainer", "http://purl.org/dc/elements/1.1/"), typeof(global::Purl.Dcmes.Elements.elementContainer));
+ }
+
+ private static Dictionary elementDictionary = new Dictionary();
+
+ private static void BuildElementDictionary() {
+ elementDictionary.Add(System.Xml.Linq.XName.Get("any", "http://purl.org/dc/elements/1.1/"), typeof(global::Purl.Dcmes.Elements.any));
+ elementDictionary.Add(System.Xml.Linq.XName.Get("title", "http://purl.org/dc/elements/1.1/"), typeof(global::Purl.Dcmes.Elements.title));
+ elementDictionary.Add(System.Xml.Linq.XName.Get("creator", "http://purl.org/dc/elements/1.1/"), typeof(global::Purl.Dcmes.Elements.creator));
+ elementDictionary.Add(System.Xml.Linq.XName.Get("subject", "http://purl.org/dc/elements/1.1/"), typeof(global::Purl.Dcmes.Elements.subject));
+ elementDictionary.Add(System.Xml.Linq.XName.Get("description", "http://purl.org/dc/elements/1.1/"), typeof(global::Purl.Dcmes.Elements.description));
+ elementDictionary.Add(System.Xml.Linq.XName.Get("publisher", "http://purl.org/dc/elements/1.1/"), typeof(global::Purl.Dcmes.Elements.publisher));
+ elementDictionary.Add(System.Xml.Linq.XName.Get("contributor", "http://purl.org/dc/elements/1.1/"), typeof(global::Purl.Dcmes.Elements.contributor));
+ elementDictionary.Add(System.Xml.Linq.XName.Get("date", "http://purl.org/dc/elements/1.1/"), typeof(global::Purl.Dcmes.Elements.date));
+ elementDictionary.Add(System.Xml.Linq.XName.Get("type", "http://purl.org/dc/elements/1.1/"), typeof(global::Purl.Dcmes.Elements.type));
+ elementDictionary.Add(System.Xml.Linq.XName.Get("format", "http://purl.org/dc/elements/1.1/"), typeof(global::Purl.Dcmes.Elements.format));
+ elementDictionary.Add(System.Xml.Linq.XName.Get("identifier", "http://purl.org/dc/elements/1.1/"), typeof(global::Purl.Dcmes.Elements.identifier));
+ elementDictionary.Add(System.Xml.Linq.XName.Get("source", "http://purl.org/dc/elements/1.1/"), typeof(global::Purl.Dcmes.Elements.source));
+ elementDictionary.Add(System.Xml.Linq.XName.Get("language", "http://purl.org/dc/elements/1.1/"), typeof(global::Purl.Dcmes.Elements.language));
+ elementDictionary.Add(System.Xml.Linq.XName.Get("relation", "http://purl.org/dc/elements/1.1/"), typeof(global::Purl.Dcmes.Elements.relation));
+ elementDictionary.Add(System.Xml.Linq.XName.Get("coverage", "http://purl.org/dc/elements/1.1/"), typeof(global::Purl.Dcmes.Elements.coverage));
+ elementDictionary.Add(System.Xml.Linq.XName.Get("rights", "http://purl.org/dc/elements/1.1/"), typeof(global::Purl.Dcmes.Elements.rights));
+ }
+
+ private static Dictionary wrapperDictionary = new Dictionary();
+
+ private static void BuildWrapperDictionary() {
+ wrapperDictionary.Add(typeof(Purl.Dcmes.Elements.any), typeof(global::Purl.Dcmes.Elements.SimpleLiteral));
+ wrapperDictionary.Add(typeof(Purl.Dcmes.Elements.title), typeof(global::Purl.Dcmes.Elements.SimpleLiteral));
+ wrapperDictionary.Add(typeof(Purl.Dcmes.Elements.creator), typeof(global::Purl.Dcmes.Elements.SimpleLiteral));
+ wrapperDictionary.Add(typeof(Purl.Dcmes.Elements.subject), typeof(global::Purl.Dcmes.Elements.SimpleLiteral));
+ wrapperDictionary.Add(typeof(Purl.Dcmes.Elements.description), typeof(global::Purl.Dcmes.Elements.SimpleLiteral));
+ wrapperDictionary.Add(typeof(Purl.Dcmes.Elements.publisher), typeof(global::Purl.Dcmes.Elements.SimpleLiteral));
+ wrapperDictionary.Add(typeof(Purl.Dcmes.Elements.contributor), typeof(global::Purl.Dcmes.Elements.SimpleLiteral));
+ wrapperDictionary.Add(typeof(Purl.Dcmes.Elements.date), typeof(global::Purl.Dcmes.Elements.SimpleLiteral));
+ wrapperDictionary.Add(typeof(Purl.Dcmes.Elements.type), typeof(global::Purl.Dcmes.Elements.SimpleLiteral));
+ wrapperDictionary.Add(typeof(Purl.Dcmes.Elements.format), typeof(global::Purl.Dcmes.Elements.SimpleLiteral));
+ wrapperDictionary.Add(typeof(Purl.Dcmes.Elements.identifier), typeof(global::Purl.Dcmes.Elements.SimpleLiteral));
+ wrapperDictionary.Add(typeof(Purl.Dcmes.Elements.source), typeof(global::Purl.Dcmes.Elements.SimpleLiteral));
+ wrapperDictionary.Add(typeof(Purl.Dcmes.Elements.language), typeof(global::Purl.Dcmes.Elements.SimpleLiteral));
+ wrapperDictionary.Add(typeof(Purl.Dcmes.Elements.relation), typeof(global::Purl.Dcmes.Elements.SimpleLiteral));
+ wrapperDictionary.Add(typeof(Purl.Dcmes.Elements.coverage), typeof(global::Purl.Dcmes.Elements.SimpleLiteral));
+ wrapperDictionary.Add(typeof(Purl.Dcmes.Elements.rights), typeof(global::Purl.Dcmes.Elements.SimpleLiteral));
+ }
+
+ private static XmlSchemaSet schemaSet;
+
+ XmlSchemaSet ILinqToXsdTypeManager.Schemas {
+ get {
+ if ((schemaSet == null)) {
+ XmlSchemaSet tempSet = new XmlSchemaSet();
+ System.Threading.Interlocked.CompareExchange(ref schemaSet, tempSet, null);
+ }
+ return schemaSet;
+ }
+ set {
+ schemaSet = value;
+ }
+ }
+
+ protected internal static void AddSchemas(XmlSchemaSet schemas) {
+ schemas.Add(schemaSet);
+ }
+
+ Dictionary ILinqToXsdTypeManager.GlobalTypeDictionary {
+ get {
+ return typeDictionary;
+ }
+ }
+
+ Dictionary ILinqToXsdTypeManager.GlobalElementDictionary {
+ get {
+ return elementDictionary;
+ }
+ }
+
+ Dictionary ILinqToXsdTypeManager.RootContentTypeMapping {
+ get {
+ return wrapperDictionary;
+ }
+ }
+
+ static LinqToXsdTypeManager() {
+ BuildTypeDictionary();
+ BuildElementDictionary();
+ BuildWrapperDictionary();
+ }
+
+ public static System.Type GetRootType() {
+ return elementDictionary[System.Xml.Linq.XName.Get("any", "http://purl.org/dc/elements/1.1/")];
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ private static LinqToXsdTypeManager typeManagerSingleton = new LinqToXsdTypeManager();
+
+ public static LinqToXsdTypeManager Instance {
+ get {
+ return typeManagerSingleton;
+ }
+ }
+ }
+
+ public partial class XRootNamespace {
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ private XDocument doc;
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ private XTypedElement rootObject;
+
+ private XRootNamespace() {
+ }
+
+ public static XRootNamespace Load(string xmlFile) {
+ XRootNamespace root = new XRootNamespace();
+ root.doc = XDocument.Load(xmlFile);
+ XTypedElement typedRoot = XTypedServices.ToXTypedElement(root.doc.Root, LinqToXsdTypeManager.Instance);
+ if ((typedRoot == null)) {
+ throw new LinqToXsdException("Invalid root element in xml document.");
+ }
+ root.rootObject = typedRoot;
+ return root;
+ }
+
+ public static XRootNamespace Load(string xmlFile, LoadOptions options) {
+ XRootNamespace root = new XRootNamespace();
+ root.doc = XDocument.Load(xmlFile, options);
+ XTypedElement typedRoot = XTypedServices.ToXTypedElement(root.doc.Root, LinqToXsdTypeManager.Instance);
+ if ((typedRoot == null)) {
+ throw new LinqToXsdException("Invalid root element in xml document.");
+ }
+ root.rootObject = typedRoot;
+ return root;
+ }
+
+ public static XRootNamespace Load(TextReader textReader) {
+ XRootNamespace root = new XRootNamespace();
+ root.doc = XDocument.Load(textReader);
+ XTypedElement typedRoot = XTypedServices.ToXTypedElement(root.doc.Root, LinqToXsdTypeManager.Instance);
+ if ((typedRoot == null)) {
+ throw new LinqToXsdException("Invalid root element in xml document.");
+ }
+ root.rootObject = typedRoot;
+ return root;
+ }
+
+ public static XRootNamespace Load(TextReader textReader, LoadOptions options) {
+ XRootNamespace root = new XRootNamespace();
+ root.doc = XDocument.Load(textReader, options);
+ XTypedElement typedRoot = XTypedServices.ToXTypedElement(root.doc.Root, LinqToXsdTypeManager.Instance);
+ if ((typedRoot == null)) {
+ throw new LinqToXsdException("Invalid root element in xml document.");
+ }
+ root.rootObject = typedRoot;
+ return root;
+ }
+
+ public static XRootNamespace Load(XmlReader xmlReader) {
+ XRootNamespace root = new XRootNamespace();
+ root.doc = XDocument.Load(xmlReader);
+ XTypedElement typedRoot = XTypedServices.ToXTypedElement(root.doc.Root, LinqToXsdTypeManager.Instance);
+ if ((typedRoot == null)) {
+ throw new LinqToXsdException("Invalid root element in xml document.");
+ }
+ root.rootObject = typedRoot;
+ return root;
+ }
+
+ public static XRootNamespace Parse(string text) {
+ XRootNamespace root = new XRootNamespace();
+ root.doc = XDocument.Parse(text);
+ XTypedElement typedRoot = XTypedServices.ToXTypedElement(root.doc.Root, LinqToXsdTypeManager.Instance);
+ if ((typedRoot == null)) {
+ throw new LinqToXsdException("Invalid root element in xml document.");
+ }
+ root.rootObject = typedRoot;
+ return root;
+ }
+
+ public static XRootNamespace Parse(string text, LoadOptions options) {
+ XRootNamespace root = new XRootNamespace();
+ root.doc = XDocument.Parse(text, options);
+ XTypedElement typedRoot = XTypedServices.ToXTypedElement(root.doc.Root, LinqToXsdTypeManager.Instance);
+ if ((typedRoot == null)) {
+ throw new LinqToXsdException("Invalid root element in xml document.");
+ }
+ root.rootObject = typedRoot;
+ return root;
+ }
+
+ public virtual void Save(string fileName) {
+ doc.Save(fileName);
+ }
+
+ public virtual void Save(TextWriter textWriter) {
+ doc.Save(textWriter);
+ }
+
+ public virtual void Save(XmlWriter writer) {
+ doc.Save(writer);
+ }
+
+ public virtual void Save(TextWriter textWriter, SaveOptions options) {
+ doc.Save(textWriter, options);
+ }
+
+ public virtual void Save(string fileName, SaveOptions options) {
+ doc.Save(fileName, options);
+ }
+
+ public virtual XDocument XDocument {
+ get {
+ return doc;
+ }
+ }
+
+ public virtual XTypedElement Root {
+ get {
+ return rootObject;
+ }
+ }
+
+ public XRootNamespace(any root) {
+ this.doc = new XDocument(root.Untyped);
+ this.rootObject = root;
+ }
+
+
+ public any any { get {return rootObject as any; } }
+
+ public XRootNamespace(title root) {
+ this.doc = new XDocument(root.Untyped);
+ this.rootObject = root;
+ }
+
+
+ public title title { get {return rootObject as title; } }
+
+ public XRootNamespace(creator root) {
+ this.doc = new XDocument(root.Untyped);
+ this.rootObject = root;
+ }
+
+
+ public creator creator { get {return rootObject as creator; } }
+
+ public XRootNamespace(subject root) {
+ this.doc = new XDocument(root.Untyped);
+ this.rootObject = root;
+ }
+
+
+ public subject subject { get {return rootObject as subject; } }
+
+ public XRootNamespace(description root) {
+ this.doc = new XDocument(root.Untyped);
+ this.rootObject = root;
+ }
+
+
+ public description description { get {return rootObject as description; } }
+
+ public XRootNamespace(publisher root) {
+ this.doc = new XDocument(root.Untyped);
+ this.rootObject = root;
+ }
+
+
+ public publisher publisher { get {return rootObject as publisher; } }
+
+ public XRootNamespace(contributor root) {
+ this.doc = new XDocument(root.Untyped);
+ this.rootObject = root;
+ }
+
+
+ public contributor contributor { get {return rootObject as contributor; } }
+
+ public XRootNamespace(date root) {
+ this.doc = new XDocument(root.Untyped);
+ this.rootObject = root;
+ }
+
+
+ public date date { get {return rootObject as date; } }
+
+ public XRootNamespace(type root) {
+ this.doc = new XDocument(root.Untyped);
+ this.rootObject = root;
+ }
+
+
+ public type type { get {return rootObject as type; } }
+
+ public XRootNamespace(format root) {
+ this.doc = new XDocument(root.Untyped);
+ this.rootObject = root;
+ }
+
+
+ public format format { get {return rootObject as format; } }
+
+ public XRootNamespace(identifier root) {
+ this.doc = new XDocument(root.Untyped);
+ this.rootObject = root;
+ }
+
+
+ public identifier identifier { get {return rootObject as identifier; } }
+
+ public XRootNamespace(source root) {
+ this.doc = new XDocument(root.Untyped);
+ this.rootObject = root;
+ }
+
+
+ public source source { get {return rootObject as source; } }
+
+ public XRootNamespace(language root) {
+ this.doc = new XDocument(root.Untyped);
+ this.rootObject = root;
+ }
+
+
+ public language language { get {return rootObject as language; } }
+
+ public XRootNamespace(relation root) {
+ this.doc = new XDocument(root.Untyped);
+ this.rootObject = root;
+ }
+
+
+ public relation relation { get {return rootObject as relation; } }
+
+ public XRootNamespace(coverage root) {
+ this.doc = new XDocument(root.Untyped);
+ this.rootObject = root;
+ }
+
+
+ public coverage coverage { get {return rootObject as coverage; } }
+
+ public XRootNamespace(rights root) {
+ this.doc = new XDocument(root.Untyped);
+ this.rootObject = root;
+ }
+
+
+ public rights rights { get {return rootObject as rights; } }
+ }
+
+ public partial class XRoot {
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ private XDocument doc;
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ private XTypedElement rootObject;
+
+ private XRoot() {
+ }
+
+ public static XRoot Load(string xmlFile) {
+ XRoot root = new XRoot();
+ root.doc = XDocument.Load(xmlFile);
+ XTypedElement typedRoot = XTypedServices.ToXTypedElement(root.doc.Root, LinqToXsdTypeManager.Instance);
+ if ((typedRoot == null)) {
+ throw new LinqToXsdException("Invalid root element in xml document.");
+ }
+ root.rootObject = typedRoot;
+ return root;
+ }
+
+ public static XRoot Load(string xmlFile, LoadOptions options) {
+ XRoot root = new XRoot();
+ root.doc = XDocument.Load(xmlFile, options);
+ XTypedElement typedRoot = XTypedServices.ToXTypedElement(root.doc.Root, LinqToXsdTypeManager.Instance);
+ if ((typedRoot == null)) {
+ throw new LinqToXsdException("Invalid root element in xml document.");
+ }
+ root.rootObject = typedRoot;
+ return root;
+ }
+
+ public static XRoot Load(TextReader textReader) {
+ XRoot root = new XRoot();
+ root.doc = XDocument.Load(textReader);
+ XTypedElement typedRoot = XTypedServices.ToXTypedElement(root.doc.Root, LinqToXsdTypeManager.Instance);
+ if ((typedRoot == null)) {
+ throw new LinqToXsdException("Invalid root element in xml document.");
+ }
+ root.rootObject = typedRoot;
+ return root;
+ }
+
+ public static XRoot Load(TextReader textReader, LoadOptions options) {
+ XRoot root = new XRoot();
+ root.doc = XDocument.Load(textReader, options);
+ XTypedElement typedRoot = XTypedServices.ToXTypedElement(root.doc.Root, LinqToXsdTypeManager.Instance);
+ if ((typedRoot == null)) {
+ throw new LinqToXsdException("Invalid root element in xml document.");
+ }
+ root.rootObject = typedRoot;
+ return root;
+ }
+
+ public static XRoot Load(XmlReader xmlReader) {
+ XRoot root = new XRoot();
+ root.doc = XDocument.Load(xmlReader);
+ XTypedElement typedRoot = XTypedServices.ToXTypedElement(root.doc.Root, LinqToXsdTypeManager.Instance);
+ if ((typedRoot == null)) {
+ throw new LinqToXsdException("Invalid root element in xml document.");
+ }
+ root.rootObject = typedRoot;
+ return root;
+ }
+
+ public static XRoot Parse(string text) {
+ XRoot root = new XRoot();
+ root.doc = XDocument.Parse(text);
+ XTypedElement typedRoot = XTypedServices.ToXTypedElement(root.doc.Root, LinqToXsdTypeManager.Instance);
+ if ((typedRoot == null)) {
+ throw new LinqToXsdException("Invalid root element in xml document.");
+ }
+ root.rootObject = typedRoot;
+ return root;
+ }
+
+ public static XRoot Parse(string text, LoadOptions options) {
+ XRoot root = new XRoot();
+ root.doc = XDocument.Parse(text, options);
+ XTypedElement typedRoot = XTypedServices.ToXTypedElement(root.doc.Root, LinqToXsdTypeManager.Instance);
+ if ((typedRoot == null)) {
+ throw new LinqToXsdException("Invalid root element in xml document.");
+ }
+ root.rootObject = typedRoot;
+ return root;
+ }
+
+ public virtual void Save(string fileName) {
+ doc.Save(fileName);
+ }
+
+ public virtual void Save(TextWriter textWriter) {
+ doc.Save(textWriter);
+ }
+
+ public virtual void Save(XmlWriter writer) {
+ doc.Save(writer);
+ }
+
+ public virtual void Save(TextWriter textWriter, SaveOptions options) {
+ doc.Save(textWriter, options);
+ }
+
+ public virtual void Save(string fileName, SaveOptions options) {
+ doc.Save(fileName, options);
+ }
+
+ public virtual XDocument XDocument {
+ get {
+ return doc;
+ }
+ }
+
+ public virtual XTypedElement Root {
+ get {
+ return rootObject;
+ }
+ }
+
+ public XRoot(global::Purl.Dcmes.Elements.any root) {
+ this.doc = new XDocument(root.Untyped);
+ this.rootObject = root;
+ }
+
+
+ public global::Purl.Dcmes.Elements.any any { get {return rootObject as global::Purl.Dcmes.Elements.any; } }
+
+ public XRoot(global::Purl.Dcmes.Elements.title root) {
+ this.doc = new XDocument(root.Untyped);
+ this.rootObject = root;
+ }
+
+
+ public global::Purl.Dcmes.Elements.title title { get {return rootObject as global::Purl.Dcmes.Elements.title; } }
+
+ public XRoot(global::Purl.Dcmes.Elements.creator root) {
+ this.doc = new XDocument(root.Untyped);
+ this.rootObject = root;
+ }
+
+
+ public global::Purl.Dcmes.Elements.creator creator { get {return rootObject as global::Purl.Dcmes.Elements.creator; } }
+
+ public XRoot(global::Purl.Dcmes.Elements.subject root) {
+ this.doc = new XDocument(root.Untyped);
+ this.rootObject = root;
+ }
+
+
+ public global::Purl.Dcmes.Elements.subject subject { get {return rootObject as global::Purl.Dcmes.Elements.subject; } }
+
+ public XRoot(global::Purl.Dcmes.Elements.description root) {
+ this.doc = new XDocument(root.Untyped);
+ this.rootObject = root;
+ }
+
+
+ public global::Purl.Dcmes.Elements.description description { get {return rootObject as global::Purl.Dcmes.Elements.description; } }
+
+ public XRoot(global::Purl.Dcmes.Elements.publisher root) {
+ this.doc = new XDocument(root.Untyped);
+ this.rootObject = root;
+ }
+
+
+ public global::Purl.Dcmes.Elements.publisher publisher { get {return rootObject as global::Purl.Dcmes.Elements.publisher; } }
+
+ public XRoot(global::Purl.Dcmes.Elements.contributor root) {
+ this.doc = new XDocument(root.Untyped);
+ this.rootObject = root;
+ }
+
+
+ public global::Purl.Dcmes.Elements.contributor contributor { get {return rootObject as global::Purl.Dcmes.Elements.contributor; } }
+
+ public XRoot(global::Purl.Dcmes.Elements.date root) {
+ this.doc = new XDocument(root.Untyped);
+ this.rootObject = root;
+ }
+
+
+ public global::Purl.Dcmes.Elements.date date { get {return rootObject as global::Purl.Dcmes.Elements.date; } }
+
+ public XRoot(global::Purl.Dcmes.Elements.type root) {
+ this.doc = new XDocument(root.Untyped);
+ this.rootObject = root;
+ }
+
+
+ public global::Purl.Dcmes.Elements.type type { get {return rootObject as global::Purl.Dcmes.Elements.type; } }
+
+ public XRoot(global::Purl.Dcmes.Elements.format root) {
+ this.doc = new XDocument(root.Untyped);
+ this.rootObject = root;
+ }
+
+
+ public global::Purl.Dcmes.Elements.format format { get {return rootObject as global::Purl.Dcmes.Elements.format; } }
+
+ public XRoot(global::Purl.Dcmes.Elements.identifier root) {
+ this.doc = new XDocument(root.Untyped);
+ this.rootObject = root;
+ }
+
+
+ public global::Purl.Dcmes.Elements.identifier identifier { get {return rootObject as global::Purl.Dcmes.Elements.identifier; } }
+
+ public XRoot(global::Purl.Dcmes.Elements.source root) {
+ this.doc = new XDocument(root.Untyped);
+ this.rootObject = root;
+ }
+
+
+ public global::Purl.Dcmes.Elements.source source { get {return rootObject as global::Purl.Dcmes.Elements.source; } }
+
+ public XRoot(global::Purl.Dcmes.Elements.language root) {
+ this.doc = new XDocument(root.Untyped);
+ this.rootObject = root;
+ }
+
+
+ public global::Purl.Dcmes.Elements.language language { get {return rootObject as global::Purl.Dcmes.Elements.language; } }
+
+ public XRoot(global::Purl.Dcmes.Elements.relation root) {
+ this.doc = new XDocument(root.Untyped);
+ this.rootObject = root;
+ }
+
+
+ public global::Purl.Dcmes.Elements.relation relation { get {return rootObject as global::Purl.Dcmes.Elements.relation; } }
+
+ public XRoot(global::Purl.Dcmes.Elements.coverage root) {
+ this.doc = new XDocument(root.Untyped);
+ this.rootObject = root;
+ }
+
+
+ public global::Purl.Dcmes.Elements.coverage coverage { get {return rootObject as global::Purl.Dcmes.Elements.coverage; } }
+
+ public XRoot(global::Purl.Dcmes.Elements.rights root) {
+ this.doc = new XDocument(root.Untyped);
+ this.rootObject = root;
+ }
+
+
+ public global::Purl.Dcmes.Elements.rights rights { get {return rootObject as global::Purl.Dcmes.Elements.rights; } }
+ }
+}
diff --git a/GeneratedSchemaLibraries/DublinCore/qualified/dc.xsd b/GeneratedSchemaLibraries/DublinCore/qualified/dc.xsd
new file mode 100644
index 00000000..1b24fc9d
--- /dev/null
+++ b/GeneratedSchemaLibraries/DublinCore/qualified/dc.xsd
@@ -0,0 +1,118 @@
+
+
+
+
+
+ DCMES 1.1 XML Schema
+ XML Schema for http://purl.org/dc/elements/1.1/ namespace
+
+ Created 2008-02-11
+
+ Created by
+
+ Tim Cole (t-cole3@uiuc.edu)
+ Tom Habing (thabing@uiuc.edu)
+ Jane Hunter (jane@dstc.edu.au)
+ Pete Johnston (p.johnston@ukoln.ac.uk),
+ Carl Lagoze (lagoze@cs.cornell.edu)
+
+ This schema declares XML elements for the 15 DC elements from the
+ http://purl.org/dc/elements/1.1/ namespace.
+
+ It defines a complexType SimpleLiteral which permits mixed content
+ and makes the xml:lang attribute available. It disallows child elements by
+ use of minOcccurs/maxOccurs.
+
+ However, this complexType does permit the derivation of other complexTypes
+ which would permit child elements.
+
+ All elements are declared as substitutable for the abstract element any,
+ which means that the default type for all elements is dc:SimpleLiteral.
+
+
+
+
+
+
+
+
+
+
+
+
+ This is the default type for all of the DC elements.
+ It permits text content only with optional
+ xml:lang attribute.
+ Text is allowed because mixed="true", but sub-elements
+ are disallowed because minOccurs="0" and maxOccurs="0"
+ are on the xs:any tag.
+
+ This complexType allows for restriction or extension permitting
+ child elements.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ This group is included as a convenience for schema authors
+ who need to refer to all the elements in the
+ http://purl.org/dc/elements/1.1/ namespace.
+
+
+
+
+
+
+
+
+
+
+
+
+
+ This complexType is included as a convenience for schema authors who need to define a root
+ or container element for all of the DC elements.
+
+
+
+
+
+
+
+
+
+
diff --git a/GeneratedSchemaLibraries/DublinCore/qualified/dcmitype.xsd b/GeneratedSchemaLibraries/DublinCore/qualified/dcmitype.xsd
new file mode 100644
index 00000000..2bffae66
--- /dev/null
+++ b/GeneratedSchemaLibraries/DublinCore/qualified/dcmitype.xsd
@@ -0,0 +1,52 @@
+
+
+
+
+
+ DCMI Type Vocabulary XML Schema
+ XML Schema for http://purl.org/dc/dcmitype/ namespace
+
+ Created 2008-02-11
+
+ Created by
+
+ Tim Cole (t-cole3@uiuc.edu)
+ Tom Habing (thabing@uiuc.edu)
+ Jane Hunter (jane@dstc.edu.au)
+ Pete Johnston (p.johnston@ukoln.ac.uk),
+ Carl Lagoze (lagoze@cs.cornell.edu)
+
+ This schema defines a simpleType which enumerates
+ the allowable values for the DCMI Type Vocabulary.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/GeneratedSchemaLibraries/DublinCore/qualified/dcterms.xsd b/GeneratedSchemaLibraries/DublinCore/qualified/dcterms.xsd
new file mode 100644
index 00000000..319b9940
--- /dev/null
+++ b/GeneratedSchemaLibraries/DublinCore/qualified/dcterms.xsd
@@ -0,0 +1,382 @@
+
+
+
+
+
+ DCterms XML Schema
+ XML Schema for http://purl.org/dc/terms/ namespace
+
+ Created 2008-02-11
+
+ Created by
+
+ Tim Cole (t-cole3@uiuc.edu)
+ Tom Habing (thabing@uiuc.edu)
+ Jane Hunter (jane@dstc.edu.au)
+ Pete Johnston (p.johnston@ukoln.ac.uk),
+ Carl Lagoze (lagoze@cs.cornell.edu)
+
+ This schema declares XML elements for the DC elements and
+ DC element refinements from the http://purl.org/dc/terms/ namespace.
+
+ It reuses the complexType dc:SimpleLiteral, imported from the dc.xsd
+ schema, which permits simple element content, and makes the xml:lang
+ attribute available.
+
+ This complexType permits the derivation of other complexTypes
+ which would permit child elements.
+
+ XML elements corresponding to DC elements are declared as substitutable for the abstract element dc:any, and
+ XML elements corresponding to DC element refinements are defined as substitutable for the base elements
+ which they refine.
+
+ This means that the default type for all XML elements (i.e. corresponding to all DC elements and
+ element refinements) is dc:SimpleLiteral.
+
+ Encoding schemes are defined as complexTypes which are restrictions
+ of the dc:SimpleLiteral complexType. These complexTypes restrict
+ values to an appropriates syntax or format using data typing,
+ regular expressions, or enumerated lists.
+
+ In order to specify one of these encodings an xsi:type attribute must
+ be used in the instance document.
+
+ Also, note that one shortcoming of this approach is that any type can be
+ applied to any of the elements or refinements. There is no convenient way
+ to restrict types to specific elements using this approach.
+
+ Changes in 2008-02-11 version:
+
+ Add element declarations corresponding to 15 new dcterms URIs, and amend use of substitutionGroups.
+
+ Add compexType definitions corresponding to ISO639-3, RFC4646.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ This group is included as a convenience for schema authors
+ who need to refer to all the DC elements and element refinements
+ in the http://purl.org/dc/elements/1.1/ and
+ http://purl.org/dc/terms namespaces.
+ N.B. Refinements available via substitution groups.
+
+
+
+
+
+
+
+
+
+
+
+
+
+ This is included as a convenience for schema authors who need to define a root
+ or container element for all of the DC elements and element refinements.
+
+
+
+
+
+
+
+
+
+
diff --git a/GeneratedSchemaLibraries/DublinCore/qualified/qualifieddc.xsd b/GeneratedSchemaLibraries/DublinCore/qualified/qualifieddc.xsd
new file mode 100644
index 00000000..e9603e4c
--- /dev/null
+++ b/GeneratedSchemaLibraries/DublinCore/qualified/qualifieddc.xsd
@@ -0,0 +1,40 @@
+
+
+
+
+
+ Qualified DC container XML Schema
+
+ Created 2008-02-11
+
+ Created by
+
+ Tim Cole (t-cole3@uiuc.edu)
+ Tom Habing (thabing@uiuc.edu)
+ Jane Hunter (jane@dstc.edu.au)
+ Pete Johnston (p.johnston@ukoln.ac.uk),
+ Carl Lagoze (lagoze@cs.cornell.edu)
+
+ This schema declares a container element for a Qualified DC application.
+
+ The declaration of the qualifieddc element uses the dcterms:elementOrRefinementContainer
+ complexType.
+
+ Note that this schema does not define a target namespace. The expectation is that
+ the qualifieddc element is assigned to a namespace by an application schema
+ which includes this schema.
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/GeneratedSchemaLibraries/DublinCore/qualified/qualifieddc.xsd.config b/GeneratedSchemaLibraries/DublinCore/qualified/qualifieddc.xsd.config
new file mode 100644
index 00000000..25ab3156
--- /dev/null
+++ b/GeneratedSchemaLibraries/DublinCore/qualified/qualifieddc.xsd.config
@@ -0,0 +1,23 @@
+
+
+
+ false
+ false
+ false
+
+
+
+
+
+
+
+
+
+
+
+ false
+
+
+
+
+
\ No newline at end of file
diff --git a/GeneratedSchemaLibraries/DublinCore/qualified/qualifieddc.xsd.cs b/GeneratedSchemaLibraries/DublinCore/qualified/qualifieddc.xsd.cs
new file mode 100644
index 00000000..43076919
--- /dev/null
+++ b/GeneratedSchemaLibraries/DublinCore/qualified/qualifieddc.xsd.cs
@@ -0,0 +1,13897 @@
+//------------------------------------------------------------------------------
+//
+// This code was generated by a tool.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+//------------------------------------------------------------------------------
+
+namespace W3C.XmlNs3 {
+ using System;
+ using System.Collections;
+ using System.Collections.Generic;
+ using System.ComponentModel;
+ using System.IO;
+ using System.Linq;
+ using System.Diagnostics;
+ using System.Xml;
+ using System.Xml.Schema;
+ using System.Xml.Linq;
+ using Xml.Schema.Linq;
+ using purl.org.dc.qualifiedContainer;
+
+
+ public sealed class lang {
+
+ private lang() {
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ public static Xml.Schema.Linq.SimpleTypeValidator TypeDefinition = new Xml.Schema.Linq.UnionSimpleTypeValidator(XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.AnyAtomicType), null, new Xml.Schema.Linq.SimpleTypeValidator[] {
+ new Xml.Schema.Linq.AtomicSimpleTypeValidator(XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.Language), null),
+ new Xml.Schema.Linq.AtomicSimpleTypeValidator(XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String), new Xml.Schema.Linq.RestrictionFacets(((Xml.Schema.Linq.RestrictionFlags)(16)), new object[] {
+ ""}, 0, 0, null, null, 0, null, null, 0, null, 0, XmlSchemaWhiteSpace.Preserve))});
+ }
+}
+namespace purl.org.dc.termsQualified {
+ using System;
+ using System.Collections;
+ using System.Collections.Generic;
+ using System.ComponentModel;
+ using System.IO;
+ using System.Linq;
+ using System.Diagnostics;
+ using System.Xml;
+ using System.Xml.Schema;
+ using System.Xml.Linq;
+ using Xml.Schema.Linq;
+ using purl.org.dc.qualifiedContainer;
+
+
+ public partial class LCSH : global::purl.org.dc.elementsQualified.SimpleLiteral, IXMetaData {
+
+ public static explicit operator LCSH(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
+
+ public override XTypedElement Clone() {
+ return XTypedServices.CloneXTypedElement(this);
+ }
+
+ public LCSH() {
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ internal static readonly System.Xml.Linq.XName TypedValueXName = System.Xml.Linq.XName.Get("TypedValue", "");
+
+ public virtual string TypedValue {
+ get {
+ XElement x = this.Untyped;
+ return XTypedServices.ParseValue(x, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String).Datatype);
+ }
+ set {
+ this.SetValueWithValidation(value, "TypedValue", LCSHLocalType.TypeDefinition);
+ }
+ }
+
+ private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("LCSH", "http://purl.org/dc/terms/");
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ System.Xml.Linq.XName IXMetaData.SchemaName {
+ get {
+ return xName;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ SchemaOrigin IXMetaData.TypeOrigin {
+ get {
+ return SchemaOrigin.Fragment;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ ILinqToXsdTypeManager IXMetaData.TypeManager {
+ get {
+ return LinqToXsdTypeManager.Instance;
+ }
+ }
+
+ private class LCSHLocalType {
+
+ private LCSHLocalType() {
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ public static Xml.Schema.Linq.SimpleTypeValidator TypeDefinition = new Xml.Schema.Linq.AtomicSimpleTypeValidator(XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String), null);
+ }
+ }
+
+ public partial class MESH : global::purl.org.dc.elementsQualified.SimpleLiteral, IXMetaData {
+
+ public static explicit operator MESH(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
+
+ public override XTypedElement Clone() {
+ return XTypedServices.CloneXTypedElement(this);
+ }
+
+ public MESH() {
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ internal static readonly System.Xml.Linq.XName TypedValueXName = System.Xml.Linq.XName.Get("TypedValue", "");
+
+ public virtual string TypedValue {
+ get {
+ XElement x = this.Untyped;
+ return XTypedServices.ParseValue(x, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String).Datatype);
+ }
+ set {
+ this.SetValueWithValidation(value, "TypedValue", MESHLocalType.TypeDefinition);
+ }
+ }
+
+ private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("MESH", "http://purl.org/dc/terms/");
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ System.Xml.Linq.XName IXMetaData.SchemaName {
+ get {
+ return xName;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ SchemaOrigin IXMetaData.TypeOrigin {
+ get {
+ return SchemaOrigin.Fragment;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ ILinqToXsdTypeManager IXMetaData.TypeManager {
+ get {
+ return LinqToXsdTypeManager.Instance;
+ }
+ }
+
+ private class MESHLocalType {
+
+ private MESHLocalType() {
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ public static Xml.Schema.Linq.SimpleTypeValidator TypeDefinition = new Xml.Schema.Linq.AtomicSimpleTypeValidator(XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String), null);
+ }
+ }
+
+ public partial class DDC : global::purl.org.dc.elementsQualified.SimpleLiteral, IXMetaData {
+
+ public static explicit operator DDC(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
+
+ public override XTypedElement Clone() {
+ return XTypedServices.CloneXTypedElement(this);
+ }
+
+ public DDC() {
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ internal static readonly System.Xml.Linq.XName TypedValueXName = System.Xml.Linq.XName.Get("TypedValue", "");
+
+ public virtual string TypedValue {
+ get {
+ XElement x = this.Untyped;
+ return XTypedServices.ParseValue(x, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String).Datatype);
+ }
+ set {
+ this.SetValueWithValidation(value, "TypedValue", DDCLocalType.TypeDefinition);
+ }
+ }
+
+ private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("DDC", "http://purl.org/dc/terms/");
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ System.Xml.Linq.XName IXMetaData.SchemaName {
+ get {
+ return xName;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ SchemaOrigin IXMetaData.TypeOrigin {
+ get {
+ return SchemaOrigin.Fragment;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ ILinqToXsdTypeManager IXMetaData.TypeManager {
+ get {
+ return LinqToXsdTypeManager.Instance;
+ }
+ }
+
+ private class DDCLocalType {
+
+ private DDCLocalType() {
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ public static Xml.Schema.Linq.SimpleTypeValidator TypeDefinition = new Xml.Schema.Linq.AtomicSimpleTypeValidator(XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String), null);
+ }
+ }
+
+ public partial class LCC : global::purl.org.dc.elementsQualified.SimpleLiteral, IXMetaData {
+
+ public static explicit operator LCC(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
+
+ public override XTypedElement Clone() {
+ return XTypedServices.CloneXTypedElement(this);
+ }
+
+ public LCC() {
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ internal static readonly System.Xml.Linq.XName TypedValueXName = System.Xml.Linq.XName.Get("TypedValue", "");
+
+ public virtual string TypedValue {
+ get {
+ XElement x = this.Untyped;
+ return XTypedServices.ParseValue(x, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String).Datatype);
+ }
+ set {
+ this.SetValueWithValidation(value, "TypedValue", LCCLocalType.TypeDefinition);
+ }
+ }
+
+ private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("LCC", "http://purl.org/dc/terms/");
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ System.Xml.Linq.XName IXMetaData.SchemaName {
+ get {
+ return xName;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ SchemaOrigin IXMetaData.TypeOrigin {
+ get {
+ return SchemaOrigin.Fragment;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ ILinqToXsdTypeManager IXMetaData.TypeManager {
+ get {
+ return LinqToXsdTypeManager.Instance;
+ }
+ }
+
+ private class LCCLocalType {
+
+ private LCCLocalType() {
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ public static Xml.Schema.Linq.SimpleTypeValidator TypeDefinition = new Xml.Schema.Linq.AtomicSimpleTypeValidator(XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String), null);
+ }
+ }
+
+ public partial class UDC : global::purl.org.dc.elementsQualified.SimpleLiteral, IXMetaData {
+
+ public static explicit operator UDC(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
+
+ public override XTypedElement Clone() {
+ return XTypedServices.CloneXTypedElement(this);
+ }
+
+ public UDC() {
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ internal static readonly System.Xml.Linq.XName TypedValueXName = System.Xml.Linq.XName.Get("TypedValue", "");
+
+ public virtual string TypedValue {
+ get {
+ XElement x = this.Untyped;
+ return XTypedServices.ParseValue(x, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String).Datatype);
+ }
+ set {
+ this.SetValueWithValidation(value, "TypedValue", UDCLocalType.TypeDefinition);
+ }
+ }
+
+ private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("UDC", "http://purl.org/dc/terms/");
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ System.Xml.Linq.XName IXMetaData.SchemaName {
+ get {
+ return xName;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ SchemaOrigin IXMetaData.TypeOrigin {
+ get {
+ return SchemaOrigin.Fragment;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ ILinqToXsdTypeManager IXMetaData.TypeManager {
+ get {
+ return LinqToXsdTypeManager.Instance;
+ }
+ }
+
+ private class UDCLocalType {
+
+ private UDCLocalType() {
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ public static Xml.Schema.Linq.SimpleTypeValidator TypeDefinition = new Xml.Schema.Linq.AtomicSimpleTypeValidator(XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String), null);
+ }
+ }
+
+ public partial class Period : global::purl.org.dc.elementsQualified.SimpleLiteral, IXMetaData {
+
+ public static explicit operator Period(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
+
+ public override XTypedElement Clone() {
+ return XTypedServices.CloneXTypedElement(this);
+ }
+
+ public Period() {
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ internal static readonly System.Xml.Linq.XName TypedValueXName = System.Xml.Linq.XName.Get("TypedValue", "");
+
+ public virtual string TypedValue {
+ get {
+ XElement x = this.Untyped;
+ return XTypedServices.ParseValue(x, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String).Datatype);
+ }
+ set {
+ this.SetValueWithValidation(value, "TypedValue", PeriodLocalType.TypeDefinition);
+ }
+ }
+
+ private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("Period", "http://purl.org/dc/terms/");
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ System.Xml.Linq.XName IXMetaData.SchemaName {
+ get {
+ return xName;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ SchemaOrigin IXMetaData.TypeOrigin {
+ get {
+ return SchemaOrigin.Fragment;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ ILinqToXsdTypeManager IXMetaData.TypeManager {
+ get {
+ return LinqToXsdTypeManager.Instance;
+ }
+ }
+
+ private class PeriodLocalType {
+
+ private PeriodLocalType() {
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ public static Xml.Schema.Linq.SimpleTypeValidator TypeDefinition = new Xml.Schema.Linq.AtomicSimpleTypeValidator(XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String), null);
+ }
+ }
+
+ public partial class W3CDTF : global::purl.org.dc.elementsQualified.SimpleLiteral, IXMetaData {
+
+ public static explicit operator W3CDTF(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
+
+ public override XTypedElement Clone() {
+ return XTypedServices.CloneXTypedElement(this);
+ }
+
+ public W3CDTF() {
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ internal static readonly System.Xml.Linq.XName TypedValueXName = System.Xml.Linq.XName.Get("TypedValue", "");
+
+ public virtual string TypedValue {
+ get {
+ XElement x = this.Untyped;
+ return XTypedServices.ParseValue(x, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.AnyAtomicType).Datatype);
+ }
+ set {
+ this.SetValueWithValidation(value, "TypedValue", W3CDTFLocalType.TypeDefinition);
+ }
+ }
+
+ private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("W3CDTF", "http://purl.org/dc/terms/");
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ System.Xml.Linq.XName IXMetaData.SchemaName {
+ get {
+ return xName;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ SchemaOrigin IXMetaData.TypeOrigin {
+ get {
+ return SchemaOrigin.Fragment;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ ILinqToXsdTypeManager IXMetaData.TypeManager {
+ get {
+ return LinqToXsdTypeManager.Instance;
+ }
+ }
+
+ private class W3CDTFLocalType {
+
+ private W3CDTFLocalType() {
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ public static Xml.Schema.Linq.SimpleTypeValidator TypeDefinition = new Xml.Schema.Linq.UnionSimpleTypeValidator(XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.AnyAtomicType), null, new Xml.Schema.Linq.SimpleTypeValidator[0]);
+ }
+ }
+
+ public partial class DCMIType : global::purl.org.dc.elementsQualified.SimpleLiteral, IXMetaData {
+
+ public static explicit operator DCMIType(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
+
+ public override XTypedElement Clone() {
+ return XTypedServices.CloneXTypedElement(this);
+ }
+
+ public DCMIType() {
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ internal static readonly System.Xml.Linq.XName TypedValueXName = System.Xml.Linq.XName.Get("TypedValue", "");
+
+ public virtual string TypedValue {
+ get {
+ XElement x = this.Untyped;
+ return XTypedServices.ParseValue(x, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.AnyAtomicType).Datatype);
+ }
+ set {
+ this.SetValueWithValidation(value, "TypedValue", DCMITypeLocalType.TypeDefinition);
+ }
+ }
+
+ private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("DCMIType", "http://purl.org/dc/terms/");
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ System.Xml.Linq.XName IXMetaData.SchemaName {
+ get {
+ return xName;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ SchemaOrigin IXMetaData.TypeOrigin {
+ get {
+ return SchemaOrigin.Fragment;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ ILinqToXsdTypeManager IXMetaData.TypeManager {
+ get {
+ return LinqToXsdTypeManager.Instance;
+ }
+ }
+
+ private class DCMITypeLocalType {
+
+ private DCMITypeLocalType() {
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ public static Xml.Schema.Linq.SimpleTypeValidator TypeDefinition = new Xml.Schema.Linq.UnionSimpleTypeValidator(XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.AnyAtomicType), null, new Xml.Schema.Linq.SimpleTypeValidator[0]);
+ }
+ }
+
+ public partial class IMT : global::purl.org.dc.elementsQualified.SimpleLiteral, IXMetaData {
+
+ public static explicit operator IMT(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
+
+ public override XTypedElement Clone() {
+ return XTypedServices.CloneXTypedElement(this);
+ }
+
+ public IMT() {
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ internal static readonly System.Xml.Linq.XName TypedValueXName = System.Xml.Linq.XName.Get("TypedValue", "");
+
+ public virtual string TypedValue {
+ get {
+ XElement x = this.Untyped;
+ return XTypedServices.ParseValue(x, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String).Datatype);
+ }
+ set {
+ this.SetValueWithValidation(value, "TypedValue", IMTLocalType.TypeDefinition);
+ }
+ }
+
+ private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("IMT", "http://purl.org/dc/terms/");
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ System.Xml.Linq.XName IXMetaData.SchemaName {
+ get {
+ return xName;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ SchemaOrigin IXMetaData.TypeOrigin {
+ get {
+ return SchemaOrigin.Fragment;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ ILinqToXsdTypeManager IXMetaData.TypeManager {
+ get {
+ return LinqToXsdTypeManager.Instance;
+ }
+ }
+
+ private class IMTLocalType {
+
+ private IMTLocalType() {
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ public static Xml.Schema.Linq.SimpleTypeValidator TypeDefinition = new Xml.Schema.Linq.AtomicSimpleTypeValidator(XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String), null);
+ }
+ }
+
+ public partial class URI : global::purl.org.dc.elementsQualified.SimpleLiteral, IXMetaData {
+
+ public static explicit operator URI(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
+
+ public override XTypedElement Clone() {
+ return XTypedServices.CloneXTypedElement(this);
+ }
+
+ public URI() {
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ internal static readonly System.Xml.Linq.XName TypedValueXName = System.Xml.Linq.XName.Get("TypedValue", "");
+
+ public virtual System.Uri TypedValue {
+ get {
+ XElement x = this.Untyped;
+ return XTypedServices.ParseValue(x, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.AnyUri).Datatype);
+ }
+ set {
+ this.SetValueWithValidation(value, "TypedValue", URILocalType.TypeDefinition);
+ }
+ }
+
+ private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("URI", "http://purl.org/dc/terms/");
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ System.Xml.Linq.XName IXMetaData.SchemaName {
+ get {
+ return xName;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ SchemaOrigin IXMetaData.TypeOrigin {
+ get {
+ return SchemaOrigin.Fragment;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ ILinqToXsdTypeManager IXMetaData.TypeManager {
+ get {
+ return LinqToXsdTypeManager.Instance;
+ }
+ }
+
+ private class URILocalType {
+
+ private URILocalType() {
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ public static Xml.Schema.Linq.SimpleTypeValidator TypeDefinition = new Xml.Schema.Linq.AtomicSimpleTypeValidator(XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.AnyUri), null);
+ }
+ }
+
+ public partial class ISO6392 : global::purl.org.dc.elementsQualified.SimpleLiteral, IXMetaData {
+
+ public static explicit operator ISO6392(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
+
+ public override XTypedElement Clone() {
+ return XTypedServices.CloneXTypedElement(this);
+ }
+
+ public ISO6392() {
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ internal static readonly System.Xml.Linq.XName TypedValueXName = System.Xml.Linq.XName.Get("TypedValue", "");
+
+ public virtual string TypedValue {
+ get {
+ XElement x = this.Untyped;
+ return XTypedServices.ParseValue(x, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String).Datatype);
+ }
+ set {
+ this.SetValueWithValidation(value, "TypedValue", ISO6392LocalType.TypeDefinition);
+ }
+ }
+
+ private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("ISO639-2", "http://purl.org/dc/terms/");
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ System.Xml.Linq.XName IXMetaData.SchemaName {
+ get {
+ return xName;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ SchemaOrigin IXMetaData.TypeOrigin {
+ get {
+ return SchemaOrigin.Fragment;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ ILinqToXsdTypeManager IXMetaData.TypeManager {
+ get {
+ return LinqToXsdTypeManager.Instance;
+ }
+ }
+
+ private class ISO6392LocalType {
+
+ private ISO6392LocalType() {
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ public static Xml.Schema.Linq.SimpleTypeValidator TypeDefinition = new Xml.Schema.Linq.AtomicSimpleTypeValidator(XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String), null);
+ }
+ }
+
+ public partial class ISO6393 : global::purl.org.dc.elementsQualified.SimpleLiteral, IXMetaData {
+
+ public static explicit operator ISO6393(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
+
+ public override XTypedElement Clone() {
+ return XTypedServices.CloneXTypedElement(this);
+ }
+
+ public ISO6393() {
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ internal static readonly System.Xml.Linq.XName TypedValueXName = System.Xml.Linq.XName.Get("TypedValue", "");
+
+ public virtual string TypedValue {
+ get {
+ XElement x = this.Untyped;
+ return XTypedServices.ParseValue(x, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String).Datatype);
+ }
+ set {
+ this.SetValueWithValidation(value, "TypedValue", ISO6393LocalType.TypeDefinition);
+ }
+ }
+
+ private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("ISO639-3", "http://purl.org/dc/terms/");
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ System.Xml.Linq.XName IXMetaData.SchemaName {
+ get {
+ return xName;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ SchemaOrigin IXMetaData.TypeOrigin {
+ get {
+ return SchemaOrigin.Fragment;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ ILinqToXsdTypeManager IXMetaData.TypeManager {
+ get {
+ return LinqToXsdTypeManager.Instance;
+ }
+ }
+
+ private class ISO6393LocalType {
+
+ private ISO6393LocalType() {
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ public static Xml.Schema.Linq.SimpleTypeValidator TypeDefinition = new Xml.Schema.Linq.AtomicSimpleTypeValidator(XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String), null);
+ }
+ }
+
+ public partial class RFC1766 : global::purl.org.dc.elementsQualified.SimpleLiteral, IXMetaData {
+
+ public static explicit operator RFC1766(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
+
+ public override XTypedElement Clone() {
+ return XTypedServices.CloneXTypedElement(this);
+ }
+
+ public RFC1766() {
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ internal static readonly System.Xml.Linq.XName TypedValueXName = System.Xml.Linq.XName.Get("TypedValue", "");
+
+ public virtual string TypedValue {
+ get {
+ XElement x = this.Untyped;
+ return XTypedServices.ParseValue(x, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.Language).Datatype);
+ }
+ set {
+ this.SetValueWithValidation(value, "TypedValue", RFC1766LocalType.TypeDefinition);
+ }
+ }
+
+ private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("RFC1766", "http://purl.org/dc/terms/");
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ System.Xml.Linq.XName IXMetaData.SchemaName {
+ get {
+ return xName;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ SchemaOrigin IXMetaData.TypeOrigin {
+ get {
+ return SchemaOrigin.Fragment;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ ILinqToXsdTypeManager IXMetaData.TypeManager {
+ get {
+ return LinqToXsdTypeManager.Instance;
+ }
+ }
+
+ private class RFC1766LocalType {
+
+ private RFC1766LocalType() {
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ public static Xml.Schema.Linq.SimpleTypeValidator TypeDefinition = new Xml.Schema.Linq.AtomicSimpleTypeValidator(XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.Language), null);
+ }
+ }
+
+ public partial class RFC3066 : global::purl.org.dc.elementsQualified.SimpleLiteral, IXMetaData {
+
+ public static explicit operator RFC3066(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
+
+ public override XTypedElement Clone() {
+ return XTypedServices.CloneXTypedElement(this);
+ }
+
+ public RFC3066() {
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ internal static readonly System.Xml.Linq.XName TypedValueXName = System.Xml.Linq.XName.Get("TypedValue", "");
+
+ public virtual string TypedValue {
+ get {
+ XElement x = this.Untyped;
+ return XTypedServices.ParseValue(x, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.Language).Datatype);
+ }
+ set {
+ this.SetValueWithValidation(value, "TypedValue", RFC3066LocalType.TypeDefinition);
+ }
+ }
+
+ private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("RFC3066", "http://purl.org/dc/terms/");
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ System.Xml.Linq.XName IXMetaData.SchemaName {
+ get {
+ return xName;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ SchemaOrigin IXMetaData.TypeOrigin {
+ get {
+ return SchemaOrigin.Fragment;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ ILinqToXsdTypeManager IXMetaData.TypeManager {
+ get {
+ return LinqToXsdTypeManager.Instance;
+ }
+ }
+
+ private class RFC3066LocalType {
+
+ private RFC3066LocalType() {
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ public static Xml.Schema.Linq.SimpleTypeValidator TypeDefinition = new Xml.Schema.Linq.AtomicSimpleTypeValidator(XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.Language), null);
+ }
+ }
+
+ public partial class RFC4646 : global::purl.org.dc.elementsQualified.SimpleLiteral, IXMetaData {
+
+ public static explicit operator RFC4646(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
+
+ public override XTypedElement Clone() {
+ return XTypedServices.CloneXTypedElement(this);
+ }
+
+ public RFC4646() {
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ internal static readonly System.Xml.Linq.XName TypedValueXName = System.Xml.Linq.XName.Get("TypedValue", "");
+
+ public virtual string TypedValue {
+ get {
+ XElement x = this.Untyped;
+ return XTypedServices.ParseValue(x, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.Language).Datatype);
+ }
+ set {
+ this.SetValueWithValidation(value, "TypedValue", RFC4646LocalType.TypeDefinition);
+ }
+ }
+
+ private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("RFC4646", "http://purl.org/dc/terms/");
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ System.Xml.Linq.XName IXMetaData.SchemaName {
+ get {
+ return xName;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ SchemaOrigin IXMetaData.TypeOrigin {
+ get {
+ return SchemaOrigin.Fragment;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ ILinqToXsdTypeManager IXMetaData.TypeManager {
+ get {
+ return LinqToXsdTypeManager.Instance;
+ }
+ }
+
+ private class RFC4646LocalType {
+
+ private RFC4646LocalType() {
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ public static Xml.Schema.Linq.SimpleTypeValidator TypeDefinition = new Xml.Schema.Linq.AtomicSimpleTypeValidator(XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.Language), null);
+ }
+ }
+
+ public partial class Point : global::purl.org.dc.elementsQualified.SimpleLiteral, IXMetaData {
+
+ public static explicit operator Point(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
+
+ public override XTypedElement Clone() {
+ return XTypedServices.CloneXTypedElement(this);
+ }
+
+ public Point() {
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ internal static readonly System.Xml.Linq.XName TypedValueXName = System.Xml.Linq.XName.Get("TypedValue", "");
+
+ public virtual string TypedValue {
+ get {
+ XElement x = this.Untyped;
+ return XTypedServices.ParseValue(x, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String).Datatype);
+ }
+ set {
+ this.SetValueWithValidation(value, "TypedValue", PointLocalType.TypeDefinition);
+ }
+ }
+
+ private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("Point", "http://purl.org/dc/terms/");
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ System.Xml.Linq.XName IXMetaData.SchemaName {
+ get {
+ return xName;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ SchemaOrigin IXMetaData.TypeOrigin {
+ get {
+ return SchemaOrigin.Fragment;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ ILinqToXsdTypeManager IXMetaData.TypeManager {
+ get {
+ return LinqToXsdTypeManager.Instance;
+ }
+ }
+
+ private class PointLocalType {
+
+ private PointLocalType() {
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ public static Xml.Schema.Linq.SimpleTypeValidator TypeDefinition = new Xml.Schema.Linq.AtomicSimpleTypeValidator(XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String), null);
+ }
+ }
+
+ public partial class ISO3166 : global::purl.org.dc.elementsQualified.SimpleLiteral, IXMetaData {
+
+ public static explicit operator ISO3166(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
+
+ public override XTypedElement Clone() {
+ return XTypedServices.CloneXTypedElement(this);
+ }
+
+ public ISO3166() {
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ internal static readonly System.Xml.Linq.XName TypedValueXName = System.Xml.Linq.XName.Get("TypedValue", "");
+
+ public virtual string TypedValue {
+ get {
+ XElement x = this.Untyped;
+ return XTypedServices.ParseValue(x, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String).Datatype);
+ }
+ set {
+ this.SetValueWithValidation(value, "TypedValue", ISO3166LocalType.TypeDefinition);
+ }
+ }
+
+ private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("ISO3166", "http://purl.org/dc/terms/");
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ System.Xml.Linq.XName IXMetaData.SchemaName {
+ get {
+ return xName;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ SchemaOrigin IXMetaData.TypeOrigin {
+ get {
+ return SchemaOrigin.Fragment;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ ILinqToXsdTypeManager IXMetaData.TypeManager {
+ get {
+ return LinqToXsdTypeManager.Instance;
+ }
+ }
+
+ private class ISO3166LocalType {
+
+ private ISO3166LocalType() {
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ public static Xml.Schema.Linq.SimpleTypeValidator TypeDefinition = new Xml.Schema.Linq.AtomicSimpleTypeValidator(XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String), null);
+ }
+ }
+
+ public partial class Box : global::purl.org.dc.elementsQualified.SimpleLiteral, IXMetaData {
+
+ public static explicit operator Box(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
+
+ public override XTypedElement Clone() {
+ return XTypedServices.CloneXTypedElement(this);
+ }
+
+ public Box() {
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ internal static readonly System.Xml.Linq.XName TypedValueXName = System.Xml.Linq.XName.Get("TypedValue", "");
+
+ public virtual string TypedValue {
+ get {
+ XElement x = this.Untyped;
+ return XTypedServices.ParseValue(x, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String).Datatype);
+ }
+ set {
+ this.SetValueWithValidation(value, "TypedValue", BoxLocalType.TypeDefinition);
+ }
+ }
+
+ private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("Box", "http://purl.org/dc/terms/");
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ System.Xml.Linq.XName IXMetaData.SchemaName {
+ get {
+ return xName;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ SchemaOrigin IXMetaData.TypeOrigin {
+ get {
+ return SchemaOrigin.Fragment;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ ILinqToXsdTypeManager IXMetaData.TypeManager {
+ get {
+ return LinqToXsdTypeManager.Instance;
+ }
+ }
+
+ private class BoxLocalType {
+
+ private BoxLocalType() {
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ public static Xml.Schema.Linq.SimpleTypeValidator TypeDefinition = new Xml.Schema.Linq.AtomicSimpleTypeValidator(XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String), null);
+ }
+ }
+
+ public partial class TGN : global::purl.org.dc.elementsQualified.SimpleLiteral, IXMetaData {
+
+ public static explicit operator TGN(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
+
+ public override XTypedElement Clone() {
+ return XTypedServices.CloneXTypedElement(this);
+ }
+
+ public TGN() {
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ internal static readonly System.Xml.Linq.XName TypedValueXName = System.Xml.Linq.XName.Get("TypedValue", "");
+
+ public virtual string TypedValue {
+ get {
+ XElement x = this.Untyped;
+ return XTypedServices.ParseValue(x, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String).Datatype);
+ }
+ set {
+ this.SetValueWithValidation(value, "TypedValue", TGNLocalType.TypeDefinition);
+ }
+ }
+
+ private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("TGN", "http://purl.org/dc/terms/");
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ System.Xml.Linq.XName IXMetaData.SchemaName {
+ get {
+ return xName;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ SchemaOrigin IXMetaData.TypeOrigin {
+ get {
+ return SchemaOrigin.Fragment;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ ILinqToXsdTypeManager IXMetaData.TypeManager {
+ get {
+ return LinqToXsdTypeManager.Instance;
+ }
+ }
+
+ private class TGNLocalType {
+
+ private TGNLocalType() {
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ public static Xml.Schema.Linq.SimpleTypeValidator TypeDefinition = new Xml.Schema.Linq.AtomicSimpleTypeValidator(XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String), null);
+ }
+ }
+
+ ///
+ ///
+ ///
+ /// This is included as a convenience for schema authors who need to define a root
+ /// or container element for all of the DC elements and element refinements.
+ ///
+ ///
+ ///
+ /// Regular expression: (((any)*))
+ ///
+ ///
+ public partial class elementOrRefinementContainer : XTypedElement, IXMetaData {
+
+ public static explicit operator elementOrRefinementContainer(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
+
+ public override XTypedElement Clone() {
+ return XTypedServices.CloneXTypedElement(this);
+ }
+
+ ///
+ ///
+ ///
+ /// This is included as a convenience for schema authors who need to define a root
+ /// or container element for all of the DC elements and element refinements.
+ ///
+ ///
+ ///
+ /// Regular expression: (((any)*))
+ ///
+ ///
+ public elementOrRefinementContainer() {
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ internal static readonly System.Xml.Linq.XName anyXName = System.Xml.Linq.XName.Get("any", "http://purl.org/dc/elements/1.1/");
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ private XTypedSubstitutedList anyField;
+
+ ///
+ ///
+ /// Occurrence: required, choice
+ ///
+ ///
+ /// Setter: Appends
+ ///
+ ///
+ /// Substitution members: any, title, creator, subject, description, publisher, contributor, date, type, format, identifier, source, language, relation, coverage, rights, alternative, tableOfContents, abstract, created, valid, available, issued, modified, dateAccepted, dateCopyrighted, dateSubmitted, extent, medium, isVersionOf, hasVersion, isReplacedBy, replaces, isRequiredBy, requires, isPartOf, hasPart, isReferencedBy, references, isFormatOf, hasFormat, conformsTo, spatial, temporal, audience, accrualMethod, accrualPeriodicity, accrualPolicy, instructionalMethod, provenance, rightsHolder, mediator, educationLevel, accessRights, license, bibliographicCitation, title, creator, subject, description, publisher, contributor, date, type, format, identifier, source, language, relation, coverage, rights
+ ///
+ ///
+ /// Regular expression: (((any)*))
+ ///
+ ///
+ public virtual IList any {
+ get {
+ if ((this.anyField == null)) {
+ this.anyField = new XTypedSubstitutedList(this, LinqToXsdTypeManager.Instance, System.Xml.Linq.XName.Get("any", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("title", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("creator", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("subject", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("description", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("publisher", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("contributor", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("date", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("type", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("format", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("identifier", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("source", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("language", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("relation", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("coverage", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("rights", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("alternative", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("tableOfContents", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("abstract", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("created", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("valid", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("available", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("issued", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("modified", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("dateAccepted", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("dateCopyrighted", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("dateSubmitted", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("extent", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("medium", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("isVersionOf", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("hasVersion", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("isReplacedBy", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("replaces", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("isRequiredBy", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("requires", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("isPartOf", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("hasPart", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("isReferencedBy", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("references", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("isFormatOf", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("hasFormat", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("conformsTo", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("spatial", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("temporal", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("audience", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("accrualMethod", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("accrualPeriodicity", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("accrualPolicy", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("instructionalMethod", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("provenance", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("rightsHolder", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("mediator", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("educationLevel", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("accessRights", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("license", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("bibliographicCitation", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("title", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("creator", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("subject", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("description", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("publisher", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("contributor", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("date", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("type", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("format", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("identifier", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("source", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("language", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("relation", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("coverage", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("rights", "http://purl.org/dc/elements/1.1/"));
+ }
+ return this.anyField;
+ }
+ set {
+ if ((value == null)) {
+ this.anyField = null;
+ }
+ else {
+ if ((this.anyField == null)) {
+ this.anyField = XTypedSubstitutedList.Initialize(this, LinqToXsdTypeManager.Instance, value, System.Xml.Linq.XName.Get("any", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("title", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("creator", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("subject", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("description", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("publisher", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("contributor", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("date", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("type", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("format", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("identifier", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("source", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("language", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("relation", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("coverage", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("rights", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("alternative", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("tableOfContents", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("abstract", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("created", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("valid", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("available", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("issued", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("modified", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("dateAccepted", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("dateCopyrighted", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("dateSubmitted", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("extent", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("medium", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("isVersionOf", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("hasVersion", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("isReplacedBy", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("replaces", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("isRequiredBy", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("requires", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("isPartOf", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("hasPart", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("isReferencedBy", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("references", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("isFormatOf", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("hasFormat", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("conformsTo", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("spatial", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("temporal", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("audience", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("accrualMethod", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("accrualPeriodicity", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("accrualPolicy", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("instructionalMethod", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("provenance", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("rightsHolder", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("mediator", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("educationLevel", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("accessRights", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("license", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("bibliographicCitation", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("title", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("creator", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("subject", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("description", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("publisher", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("contributor", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("date", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("type", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("format", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("identifier", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("source", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("language", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("relation", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("coverage", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("rights", "http://purl.org/dc/elements/1.1/"));
+ }
+ else {
+ XTypedServices.SetList(this.anyField, value);
+ }
+ }
+ }
+ }
+
+ private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("elementOrRefinementContainer", "http://purl.org/dc/terms/");
+
+ static elementOrRefinementContainer() {
+ BuildElementDictionary();
+ contentModel = new ChoiceContentModelEntity(new SequenceContentModelEntity(new ChoiceContentModelEntity(new SubstitutedContentModelEntity(System.Xml.Linq.XName.Get("any", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("title", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("creator", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("subject", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("description", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("publisher", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("contributor", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("date", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("type", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("format", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("identifier", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("source", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("language", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("relation", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("coverage", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("rights", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("alternative", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("tableOfContents", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("abstract", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("created", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("valid", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("available", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("issued", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("modified", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("dateAccepted", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("dateCopyrighted", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("dateSubmitted", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("extent", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("medium", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("isVersionOf", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("hasVersion", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("isReplacedBy", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("replaces", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("isRequiredBy", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("requires", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("isPartOf", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("hasPart", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("isReferencedBy", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("references", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("isFormatOf", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("hasFormat", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("conformsTo", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("spatial", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("temporal", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("audience", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("accrualMethod", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("accrualPeriodicity", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("accrualPolicy", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("instructionalMethod", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("provenance", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("rightsHolder", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("mediator", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("educationLevel", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("accessRights", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("license", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("bibliographicCitation", "http://purl.org/dc/terms/"), System.Xml.Linq.XName.Get("title", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("creator", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("subject", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("description", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("publisher", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("contributor", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("date", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("type", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("format", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("identifier", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("source", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("language", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("relation", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("coverage", "http://purl.org/dc/elements/1.1/"), System.Xml.Linq.XName.Get("rights", "http://purl.org/dc/elements/1.1/")))));
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ private static Dictionary localElementDictionary = new Dictionary();
+
+ private static void BuildElementDictionary() {
+ localElementDictionary.Add(anyXName, typeof(purl.org.dc.elementsQualified.any));
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ Dictionary IXMetaData.LocalElementsDictionary {
+ get {
+ return localElementDictionary;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ private static ContentModelEntity contentModel;
+
+ ContentModelEntity IXMetaData.GetContentModel() {
+ return contentModel;
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ System.Xml.Linq.XName IXMetaData.SchemaName {
+ get {
+ return xName;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ SchemaOrigin IXMetaData.TypeOrigin {
+ get {
+ return SchemaOrigin.Fragment;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ ILinqToXsdTypeManager IXMetaData.TypeManager {
+ get {
+ return LinqToXsdTypeManager.Instance;
+ }
+ }
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public partial class title : global::purl.org.dc.elementsQualified.title, IXMetaData {
+
+ public new static title Load(string xmlFile) {
+ return ((title)(XTypedServices.ToXTypedElement(XElement.Load(xmlFile), LinqToXsdTypeManager.Instance)));
+ }
+
+ public static title Load(System.IO.TextReader xmlFile) {
+ return ((title)(XTypedServices.ToXTypedElement(XElement.Load(xmlFile), LinqToXsdTypeManager.Instance)));
+ }
+
+ public new static title Parse(string xml) {
+ return ((title)(XTypedServices.ToXTypedElement(XElement.Parse(xml), LinqToXsdTypeManager.Instance)));
+ }
+
+ public static explicit operator title(XElement xe) { return (title)XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
+
+ public override XTypedElement Clone() {
+ return new title(((purl.org.dc.elementsQualified.SimpleLiteral)(this.Content.Clone())));
+ }
+
+ protected title(bool setNull) :
+ base(true) {
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ private purl.org.dc.elementsQualified.SimpleLiteral ContentField;
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public title() :
+ base(true) {
+ SetInnerType(new purl.org.dc.elementsQualified.SimpleLiteral());
+ }
+
+ public override XElement Untyped {
+ get {
+ return base.Untyped;
+ }
+ set {
+ base.Untyped = value;
+ if ((this.ContentField != null)) {
+ this.ContentField.Untyped = value;
+ }
+ }
+ }
+
+ public new virtual purl.org.dc.elementsQualified.SimpleLiteral Content {
+ get {
+ return ContentField;
+ }
+ }
+
+ private void SetInnerType(purl.org.dc.elementsQualified.SimpleLiteral ContentField) {
+ this.ContentField = ((purl.org.dc.elementsQualified.SimpleLiteral)(XTypedServices.GetCloneIfRooted(ContentField)));
+ XTypedServices.SetName(this, this.ContentField);
+ base.SetSubstitutionMember(ContentField);
+ }
+
+ protected virtual void SetSubstitutionMember(purl.org.dc.elementsQualified.SimpleLiteral ContentField) {
+ this.ContentField = ContentField;
+ base.SetSubstitutionMember(ContentField);
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public title(purl.org.dc.elementsQualified.SimpleLiteral content) :
+ base(true) {
+ SetInnerType(content);
+ }
+
+ private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("title", "http://purl.org/dc/terms/");
+
+ Dictionary IXMetaData.LocalElementsDictionary {
+ get {
+ IXMetaData schemaMetaData = ((IXMetaData)(this.Content));
+ return schemaMetaData.LocalElementsDictionary;
+ }
+ }
+
+ XTypedElement IXMetaData.Content {
+ get {
+ return this.Content;
+ }
+ }
+
+ ContentModelEntity IXMetaData.GetContentModel() {
+ return ContentModelEntity.Default;
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ System.Xml.Linq.XName IXMetaData.SchemaName {
+ get {
+ return xName;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ SchemaOrigin IXMetaData.TypeOrigin {
+ get {
+ return SchemaOrigin.Element;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ ILinqToXsdTypeManager IXMetaData.TypeManager {
+ get {
+ return LinqToXsdTypeManager.Instance;
+ }
+ }
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public partial class creator : global::purl.org.dc.elementsQualified.creator, IXMetaData {
+
+ public new static creator Load(string xmlFile) {
+ return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance);
+ }
+
+ public static creator Load(System.IO.TextReader xmlFile) {
+ return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance);
+ }
+
+ public new static creator Parse(string xml) {
+ return XTypedServices.Parse(xml, LinqToXsdTypeManager.Instance);
+ }
+
+ public static explicit operator creator(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
+
+ public override XTypedElement Clone() {
+ return new creator(((purl.org.dc.elementsQualified.SimpleLiteral)(this.Content.Clone())));
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ private purl.org.dc.elementsQualified.SimpleLiteral ContentField;
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public creator() :
+ base(true) {
+ SetInnerType(new purl.org.dc.elementsQualified.SimpleLiteral());
+ }
+
+ public override XElement Untyped {
+ get {
+ return base.Untyped;
+ }
+ set {
+ base.Untyped = value;
+ this.ContentField.Untyped = value;
+ }
+ }
+
+ public new virtual purl.org.dc.elementsQualified.SimpleLiteral Content {
+ get {
+ return ContentField;
+ }
+ }
+
+ private void SetInnerType(purl.org.dc.elementsQualified.SimpleLiteral ContentField) {
+ this.ContentField = ((purl.org.dc.elementsQualified.SimpleLiteral)(XTypedServices.GetCloneIfRooted(ContentField)));
+ XTypedServices.SetName(this, this.ContentField);
+ base.SetSubstitutionMember(ContentField);
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public creator(purl.org.dc.elementsQualified.SimpleLiteral content) :
+ base(true) {
+ SetInnerType(content);
+ }
+
+ private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("creator", "http://purl.org/dc/terms/");
+
+ Dictionary IXMetaData.LocalElementsDictionary {
+ get {
+ IXMetaData schemaMetaData = ((IXMetaData)(this.Content));
+ return schemaMetaData.LocalElementsDictionary;
+ }
+ }
+
+ XTypedElement IXMetaData.Content {
+ get {
+ return this.Content;
+ }
+ }
+
+ ContentModelEntity IXMetaData.GetContentModel() {
+ return ContentModelEntity.Default;
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ System.Xml.Linq.XName IXMetaData.SchemaName {
+ get {
+ return xName;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ SchemaOrigin IXMetaData.TypeOrigin {
+ get {
+ return SchemaOrigin.Element;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ ILinqToXsdTypeManager IXMetaData.TypeManager {
+ get {
+ return LinqToXsdTypeManager.Instance;
+ }
+ }
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public partial class subject : global::purl.org.dc.elementsQualified.subject, IXMetaData {
+
+ public new static subject Load(string xmlFile) {
+ return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance);
+ }
+
+ public static subject Load(System.IO.TextReader xmlFile) {
+ return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance);
+ }
+
+ public new static subject Parse(string xml) {
+ return XTypedServices.Parse(xml, LinqToXsdTypeManager.Instance);
+ }
+
+ public static explicit operator subject(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
+
+ public override XTypedElement Clone() {
+ return new subject(((purl.org.dc.elementsQualified.SimpleLiteral)(this.Content.Clone())));
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ private purl.org.dc.elementsQualified.SimpleLiteral ContentField;
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public subject() :
+ base(true) {
+ SetInnerType(new purl.org.dc.elementsQualified.SimpleLiteral());
+ }
+
+ public override XElement Untyped {
+ get {
+ return base.Untyped;
+ }
+ set {
+ base.Untyped = value;
+ this.ContentField.Untyped = value;
+ }
+ }
+
+ public new virtual purl.org.dc.elementsQualified.SimpleLiteral Content {
+ get {
+ return ContentField;
+ }
+ }
+
+ private void SetInnerType(purl.org.dc.elementsQualified.SimpleLiteral ContentField) {
+ this.ContentField = ((purl.org.dc.elementsQualified.SimpleLiteral)(XTypedServices.GetCloneIfRooted(ContentField)));
+ XTypedServices.SetName(this, this.ContentField);
+ base.SetSubstitutionMember(ContentField);
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public subject(purl.org.dc.elementsQualified.SimpleLiteral content) :
+ base(true) {
+ SetInnerType(content);
+ }
+
+ private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("subject", "http://purl.org/dc/terms/");
+
+ Dictionary IXMetaData.LocalElementsDictionary {
+ get {
+ IXMetaData schemaMetaData = ((IXMetaData)(this.Content));
+ return schemaMetaData.LocalElementsDictionary;
+ }
+ }
+
+ XTypedElement IXMetaData.Content {
+ get {
+ return this.Content;
+ }
+ }
+
+ ContentModelEntity IXMetaData.GetContentModel() {
+ return ContentModelEntity.Default;
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ System.Xml.Linq.XName IXMetaData.SchemaName {
+ get {
+ return xName;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ SchemaOrigin IXMetaData.TypeOrigin {
+ get {
+ return SchemaOrigin.Element;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ ILinqToXsdTypeManager IXMetaData.TypeManager {
+ get {
+ return LinqToXsdTypeManager.Instance;
+ }
+ }
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public partial class description : global::purl.org.dc.elementsQualified.description, IXMetaData {
+
+ public new static description Load(string xmlFile) {
+ return ((description)(XTypedServices.ToXTypedElement(XElement.Load(xmlFile), LinqToXsdTypeManager.Instance)));
+ }
+
+ public static description Load(System.IO.TextReader xmlFile) {
+ return ((description)(XTypedServices.ToXTypedElement(XElement.Load(xmlFile), LinqToXsdTypeManager.Instance)));
+ }
+
+ public new static description Parse(string xml) {
+ return ((description)(XTypedServices.ToXTypedElement(XElement.Parse(xml), LinqToXsdTypeManager.Instance)));
+ }
+
+ public static explicit operator description(XElement xe) { return (description)XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
+
+ public override XTypedElement Clone() {
+ return new description(((purl.org.dc.elementsQualified.SimpleLiteral)(this.Content.Clone())));
+ }
+
+ protected description(bool setNull) :
+ base(true) {
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ private purl.org.dc.elementsQualified.SimpleLiteral ContentField;
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public description() :
+ base(true) {
+ SetInnerType(new purl.org.dc.elementsQualified.SimpleLiteral());
+ }
+
+ public override XElement Untyped {
+ get {
+ return base.Untyped;
+ }
+ set {
+ base.Untyped = value;
+ if ((this.ContentField != null)) {
+ this.ContentField.Untyped = value;
+ }
+ }
+ }
+
+ public new virtual purl.org.dc.elementsQualified.SimpleLiteral Content {
+ get {
+ return ContentField;
+ }
+ }
+
+ private void SetInnerType(purl.org.dc.elementsQualified.SimpleLiteral ContentField) {
+ this.ContentField = ((purl.org.dc.elementsQualified.SimpleLiteral)(XTypedServices.GetCloneIfRooted(ContentField)));
+ XTypedServices.SetName(this, this.ContentField);
+ base.SetSubstitutionMember(ContentField);
+ }
+
+ protected virtual void SetSubstitutionMember(purl.org.dc.elementsQualified.SimpleLiteral ContentField) {
+ this.ContentField = ContentField;
+ base.SetSubstitutionMember(ContentField);
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public description(purl.org.dc.elementsQualified.SimpleLiteral content) :
+ base(true) {
+ SetInnerType(content);
+ }
+
+ private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("description", "http://purl.org/dc/terms/");
+
+ Dictionary IXMetaData.LocalElementsDictionary {
+ get {
+ IXMetaData schemaMetaData = ((IXMetaData)(this.Content));
+ return schemaMetaData.LocalElementsDictionary;
+ }
+ }
+
+ XTypedElement IXMetaData.Content {
+ get {
+ return this.Content;
+ }
+ }
+
+ ContentModelEntity IXMetaData.GetContentModel() {
+ return ContentModelEntity.Default;
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ System.Xml.Linq.XName IXMetaData.SchemaName {
+ get {
+ return xName;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ SchemaOrigin IXMetaData.TypeOrigin {
+ get {
+ return SchemaOrigin.Element;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ ILinqToXsdTypeManager IXMetaData.TypeManager {
+ get {
+ return LinqToXsdTypeManager.Instance;
+ }
+ }
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public partial class publisher : global::purl.org.dc.elementsQualified.publisher, IXMetaData {
+
+ public new static publisher Load(string xmlFile) {
+ return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance);
+ }
+
+ public static publisher Load(System.IO.TextReader xmlFile) {
+ return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance);
+ }
+
+ public new static publisher Parse(string xml) {
+ return XTypedServices.Parse(xml, LinqToXsdTypeManager.Instance);
+ }
+
+ public static explicit operator publisher(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
+
+ public override XTypedElement Clone() {
+ return new publisher(((purl.org.dc.elementsQualified.SimpleLiteral)(this.Content.Clone())));
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ private purl.org.dc.elementsQualified.SimpleLiteral ContentField;
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public publisher() :
+ base(true) {
+ SetInnerType(new purl.org.dc.elementsQualified.SimpleLiteral());
+ }
+
+ public override XElement Untyped {
+ get {
+ return base.Untyped;
+ }
+ set {
+ base.Untyped = value;
+ this.ContentField.Untyped = value;
+ }
+ }
+
+ public new virtual purl.org.dc.elementsQualified.SimpleLiteral Content {
+ get {
+ return ContentField;
+ }
+ }
+
+ private void SetInnerType(purl.org.dc.elementsQualified.SimpleLiteral ContentField) {
+ this.ContentField = ((purl.org.dc.elementsQualified.SimpleLiteral)(XTypedServices.GetCloneIfRooted(ContentField)));
+ XTypedServices.SetName(this, this.ContentField);
+ base.SetSubstitutionMember(ContentField);
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public publisher(purl.org.dc.elementsQualified.SimpleLiteral content) :
+ base(true) {
+ SetInnerType(content);
+ }
+
+ private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("publisher", "http://purl.org/dc/terms/");
+
+ Dictionary IXMetaData.LocalElementsDictionary {
+ get {
+ IXMetaData schemaMetaData = ((IXMetaData)(this.Content));
+ return schemaMetaData.LocalElementsDictionary;
+ }
+ }
+
+ XTypedElement IXMetaData.Content {
+ get {
+ return this.Content;
+ }
+ }
+
+ ContentModelEntity IXMetaData.GetContentModel() {
+ return ContentModelEntity.Default;
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ System.Xml.Linq.XName IXMetaData.SchemaName {
+ get {
+ return xName;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ SchemaOrigin IXMetaData.TypeOrigin {
+ get {
+ return SchemaOrigin.Element;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ ILinqToXsdTypeManager IXMetaData.TypeManager {
+ get {
+ return LinqToXsdTypeManager.Instance;
+ }
+ }
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public partial class contributor : global::purl.org.dc.elementsQualified.contributor, IXMetaData {
+
+ public new static contributor Load(string xmlFile) {
+ return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance);
+ }
+
+ public static contributor Load(System.IO.TextReader xmlFile) {
+ return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance);
+ }
+
+ public new static contributor Parse(string xml) {
+ return XTypedServices.Parse(xml, LinqToXsdTypeManager.Instance);
+ }
+
+ public static explicit operator contributor(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
+
+ public override XTypedElement Clone() {
+ return new contributor(((purl.org.dc.elementsQualified.SimpleLiteral)(this.Content.Clone())));
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ private purl.org.dc.elementsQualified.SimpleLiteral ContentField;
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public contributor() :
+ base(true) {
+ SetInnerType(new purl.org.dc.elementsQualified.SimpleLiteral());
+ }
+
+ public override XElement Untyped {
+ get {
+ return base.Untyped;
+ }
+ set {
+ base.Untyped = value;
+ this.ContentField.Untyped = value;
+ }
+ }
+
+ public new virtual purl.org.dc.elementsQualified.SimpleLiteral Content {
+ get {
+ return ContentField;
+ }
+ }
+
+ private void SetInnerType(purl.org.dc.elementsQualified.SimpleLiteral ContentField) {
+ this.ContentField = ((purl.org.dc.elementsQualified.SimpleLiteral)(XTypedServices.GetCloneIfRooted(ContentField)));
+ XTypedServices.SetName(this, this.ContentField);
+ base.SetSubstitutionMember(ContentField);
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public contributor(purl.org.dc.elementsQualified.SimpleLiteral content) :
+ base(true) {
+ SetInnerType(content);
+ }
+
+ private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("contributor", "http://purl.org/dc/terms/");
+
+ Dictionary IXMetaData.LocalElementsDictionary {
+ get {
+ IXMetaData schemaMetaData = ((IXMetaData)(this.Content));
+ return schemaMetaData.LocalElementsDictionary;
+ }
+ }
+
+ XTypedElement IXMetaData.Content {
+ get {
+ return this.Content;
+ }
+ }
+
+ ContentModelEntity IXMetaData.GetContentModel() {
+ return ContentModelEntity.Default;
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ System.Xml.Linq.XName IXMetaData.SchemaName {
+ get {
+ return xName;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ SchemaOrigin IXMetaData.TypeOrigin {
+ get {
+ return SchemaOrigin.Element;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ ILinqToXsdTypeManager IXMetaData.TypeManager {
+ get {
+ return LinqToXsdTypeManager.Instance;
+ }
+ }
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public partial class date : global::purl.org.dc.elementsQualified.date, IXMetaData {
+
+ public new static date Load(string xmlFile) {
+ return ((date)(XTypedServices.ToXTypedElement(XElement.Load(xmlFile), LinqToXsdTypeManager.Instance)));
+ }
+
+ public static date Load(System.IO.TextReader xmlFile) {
+ return ((date)(XTypedServices.ToXTypedElement(XElement.Load(xmlFile), LinqToXsdTypeManager.Instance)));
+ }
+
+ public new static date Parse(string xml) {
+ return ((date)(XTypedServices.ToXTypedElement(XElement.Parse(xml), LinqToXsdTypeManager.Instance)));
+ }
+
+ public static explicit operator date(XElement xe) { return (date)XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
+
+ public override XTypedElement Clone() {
+ return new date(((purl.org.dc.elementsQualified.SimpleLiteral)(this.Content.Clone())));
+ }
+
+ protected date(bool setNull) :
+ base(true) {
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ private purl.org.dc.elementsQualified.SimpleLiteral ContentField;
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public date() :
+ base(true) {
+ SetInnerType(new purl.org.dc.elementsQualified.SimpleLiteral());
+ }
+
+ public override XElement Untyped {
+ get {
+ return base.Untyped;
+ }
+ set {
+ base.Untyped = value;
+ if ((this.ContentField != null)) {
+ this.ContentField.Untyped = value;
+ }
+ }
+ }
+
+ public new virtual purl.org.dc.elementsQualified.SimpleLiteral Content {
+ get {
+ return ContentField;
+ }
+ }
+
+ private void SetInnerType(purl.org.dc.elementsQualified.SimpleLiteral ContentField) {
+ this.ContentField = ((purl.org.dc.elementsQualified.SimpleLiteral)(XTypedServices.GetCloneIfRooted(ContentField)));
+ XTypedServices.SetName(this, this.ContentField);
+ base.SetSubstitutionMember(ContentField);
+ }
+
+ protected virtual void SetSubstitutionMember(purl.org.dc.elementsQualified.SimpleLiteral ContentField) {
+ this.ContentField = ContentField;
+ base.SetSubstitutionMember(ContentField);
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public date(purl.org.dc.elementsQualified.SimpleLiteral content) :
+ base(true) {
+ SetInnerType(content);
+ }
+
+ private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("date", "http://purl.org/dc/terms/");
+
+ Dictionary IXMetaData.LocalElementsDictionary {
+ get {
+ IXMetaData schemaMetaData = ((IXMetaData)(this.Content));
+ return schemaMetaData.LocalElementsDictionary;
+ }
+ }
+
+ XTypedElement IXMetaData.Content {
+ get {
+ return this.Content;
+ }
+ }
+
+ ContentModelEntity IXMetaData.GetContentModel() {
+ return ContentModelEntity.Default;
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ System.Xml.Linq.XName IXMetaData.SchemaName {
+ get {
+ return xName;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ SchemaOrigin IXMetaData.TypeOrigin {
+ get {
+ return SchemaOrigin.Element;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ ILinqToXsdTypeManager IXMetaData.TypeManager {
+ get {
+ return LinqToXsdTypeManager.Instance;
+ }
+ }
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public partial class type : global::purl.org.dc.elementsQualified.type, IXMetaData {
+
+ public new static type Load(string xmlFile) {
+ return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance);
+ }
+
+ public static type Load(System.IO.TextReader xmlFile) {
+ return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance);
+ }
+
+ public new static type Parse(string xml) {
+ return XTypedServices.Parse(xml, LinqToXsdTypeManager.Instance);
+ }
+
+ public static explicit operator type(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
+
+ public override XTypedElement Clone() {
+ return new type(((purl.org.dc.elementsQualified.SimpleLiteral)(this.Content.Clone())));
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ private purl.org.dc.elementsQualified.SimpleLiteral ContentField;
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public type() :
+ base(true) {
+ SetInnerType(new purl.org.dc.elementsQualified.SimpleLiteral());
+ }
+
+ public override XElement Untyped {
+ get {
+ return base.Untyped;
+ }
+ set {
+ base.Untyped = value;
+ this.ContentField.Untyped = value;
+ }
+ }
+
+ public new virtual purl.org.dc.elementsQualified.SimpleLiteral Content {
+ get {
+ return ContentField;
+ }
+ }
+
+ private void SetInnerType(purl.org.dc.elementsQualified.SimpleLiteral ContentField) {
+ this.ContentField = ((purl.org.dc.elementsQualified.SimpleLiteral)(XTypedServices.GetCloneIfRooted(ContentField)));
+ XTypedServices.SetName(this, this.ContentField);
+ base.SetSubstitutionMember(ContentField);
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public type(purl.org.dc.elementsQualified.SimpleLiteral content) :
+ base(true) {
+ SetInnerType(content);
+ }
+
+ private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("type", "http://purl.org/dc/terms/");
+
+ Dictionary IXMetaData.LocalElementsDictionary {
+ get {
+ IXMetaData schemaMetaData = ((IXMetaData)(this.Content));
+ return schemaMetaData.LocalElementsDictionary;
+ }
+ }
+
+ XTypedElement IXMetaData.Content {
+ get {
+ return this.Content;
+ }
+ }
+
+ ContentModelEntity IXMetaData.GetContentModel() {
+ return ContentModelEntity.Default;
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ System.Xml.Linq.XName IXMetaData.SchemaName {
+ get {
+ return xName;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ SchemaOrigin IXMetaData.TypeOrigin {
+ get {
+ return SchemaOrigin.Element;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ ILinqToXsdTypeManager IXMetaData.TypeManager {
+ get {
+ return LinqToXsdTypeManager.Instance;
+ }
+ }
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public partial class format : global::purl.org.dc.elementsQualified.format, IXMetaData {
+
+ public new static format Load(string xmlFile) {
+ return ((format)(XTypedServices.ToXTypedElement(XElement.Load(xmlFile), LinqToXsdTypeManager.Instance)));
+ }
+
+ public static format Load(System.IO.TextReader xmlFile) {
+ return ((format)(XTypedServices.ToXTypedElement(XElement.Load(xmlFile), LinqToXsdTypeManager.Instance)));
+ }
+
+ public new static format Parse(string xml) {
+ return ((format)(XTypedServices.ToXTypedElement(XElement.Parse(xml), LinqToXsdTypeManager.Instance)));
+ }
+
+ public static explicit operator format(XElement xe) { return (format)XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
+
+ public override XTypedElement Clone() {
+ return new format(((purl.org.dc.elementsQualified.SimpleLiteral)(this.Content.Clone())));
+ }
+
+ protected format(bool setNull) :
+ base(true) {
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ private purl.org.dc.elementsQualified.SimpleLiteral ContentField;
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public format() :
+ base(true) {
+ SetInnerType(new purl.org.dc.elementsQualified.SimpleLiteral());
+ }
+
+ public override XElement Untyped {
+ get {
+ return base.Untyped;
+ }
+ set {
+ base.Untyped = value;
+ if ((this.ContentField != null)) {
+ this.ContentField.Untyped = value;
+ }
+ }
+ }
+
+ public new virtual purl.org.dc.elementsQualified.SimpleLiteral Content {
+ get {
+ return ContentField;
+ }
+ }
+
+ private void SetInnerType(purl.org.dc.elementsQualified.SimpleLiteral ContentField) {
+ this.ContentField = ((purl.org.dc.elementsQualified.SimpleLiteral)(XTypedServices.GetCloneIfRooted(ContentField)));
+ XTypedServices.SetName(this, this.ContentField);
+ base.SetSubstitutionMember(ContentField);
+ }
+
+ protected virtual void SetSubstitutionMember(purl.org.dc.elementsQualified.SimpleLiteral ContentField) {
+ this.ContentField = ContentField;
+ base.SetSubstitutionMember(ContentField);
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public format(purl.org.dc.elementsQualified.SimpleLiteral content) :
+ base(true) {
+ SetInnerType(content);
+ }
+
+ private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("format", "http://purl.org/dc/terms/");
+
+ Dictionary IXMetaData.LocalElementsDictionary {
+ get {
+ IXMetaData schemaMetaData = ((IXMetaData)(this.Content));
+ return schemaMetaData.LocalElementsDictionary;
+ }
+ }
+
+ XTypedElement IXMetaData.Content {
+ get {
+ return this.Content;
+ }
+ }
+
+ ContentModelEntity IXMetaData.GetContentModel() {
+ return ContentModelEntity.Default;
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ System.Xml.Linq.XName IXMetaData.SchemaName {
+ get {
+ return xName;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ SchemaOrigin IXMetaData.TypeOrigin {
+ get {
+ return SchemaOrigin.Element;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ ILinqToXsdTypeManager IXMetaData.TypeManager {
+ get {
+ return LinqToXsdTypeManager.Instance;
+ }
+ }
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public partial class identifier : global::purl.org.dc.elementsQualified.identifier, IXMetaData {
+
+ public new static identifier Load(string xmlFile) {
+ return ((identifier)(XTypedServices.ToXTypedElement(XElement.Load(xmlFile), LinqToXsdTypeManager.Instance)));
+ }
+
+ public static identifier Load(System.IO.TextReader xmlFile) {
+ return ((identifier)(XTypedServices.ToXTypedElement(XElement.Load(xmlFile), LinqToXsdTypeManager.Instance)));
+ }
+
+ public new static identifier Parse(string xml) {
+ return ((identifier)(XTypedServices.ToXTypedElement(XElement.Parse(xml), LinqToXsdTypeManager.Instance)));
+ }
+
+ public static explicit operator identifier(XElement xe) { return (identifier)XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
+
+ public override XTypedElement Clone() {
+ return new identifier(((purl.org.dc.elementsQualified.SimpleLiteral)(this.Content.Clone())));
+ }
+
+ protected identifier(bool setNull) :
+ base(true) {
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ private purl.org.dc.elementsQualified.SimpleLiteral ContentField;
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public identifier() :
+ base(true) {
+ SetInnerType(new purl.org.dc.elementsQualified.SimpleLiteral());
+ }
+
+ public override XElement Untyped {
+ get {
+ return base.Untyped;
+ }
+ set {
+ base.Untyped = value;
+ if ((this.ContentField != null)) {
+ this.ContentField.Untyped = value;
+ }
+ }
+ }
+
+ public new virtual purl.org.dc.elementsQualified.SimpleLiteral Content {
+ get {
+ return ContentField;
+ }
+ }
+
+ private void SetInnerType(purl.org.dc.elementsQualified.SimpleLiteral ContentField) {
+ this.ContentField = ((purl.org.dc.elementsQualified.SimpleLiteral)(XTypedServices.GetCloneIfRooted(ContentField)));
+ XTypedServices.SetName(this, this.ContentField);
+ base.SetSubstitutionMember(ContentField);
+ }
+
+ protected virtual void SetSubstitutionMember(purl.org.dc.elementsQualified.SimpleLiteral ContentField) {
+ this.ContentField = ContentField;
+ base.SetSubstitutionMember(ContentField);
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public identifier(purl.org.dc.elementsQualified.SimpleLiteral content) :
+ base(true) {
+ SetInnerType(content);
+ }
+
+ private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("identifier", "http://purl.org/dc/terms/");
+
+ Dictionary IXMetaData.LocalElementsDictionary {
+ get {
+ IXMetaData schemaMetaData = ((IXMetaData)(this.Content));
+ return schemaMetaData.LocalElementsDictionary;
+ }
+ }
+
+ XTypedElement IXMetaData.Content {
+ get {
+ return this.Content;
+ }
+ }
+
+ ContentModelEntity IXMetaData.GetContentModel() {
+ return ContentModelEntity.Default;
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ System.Xml.Linq.XName IXMetaData.SchemaName {
+ get {
+ return xName;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ SchemaOrigin IXMetaData.TypeOrigin {
+ get {
+ return SchemaOrigin.Element;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ ILinqToXsdTypeManager IXMetaData.TypeManager {
+ get {
+ return LinqToXsdTypeManager.Instance;
+ }
+ }
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public partial class source : global::purl.org.dc.elementsQualified.source, IXMetaData {
+
+ public new static source Load(string xmlFile) {
+ return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance);
+ }
+
+ public static source Load(System.IO.TextReader xmlFile) {
+ return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance);
+ }
+
+ public new static source Parse(string xml) {
+ return XTypedServices.Parse(xml, LinqToXsdTypeManager.Instance);
+ }
+
+ public static explicit operator source(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
+
+ public override XTypedElement Clone() {
+ return new source(((purl.org.dc.elementsQualified.SimpleLiteral)(this.Content.Clone())));
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ private purl.org.dc.elementsQualified.SimpleLiteral ContentField;
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public source() :
+ base(true) {
+ SetInnerType(new purl.org.dc.elementsQualified.SimpleLiteral());
+ }
+
+ public override XElement Untyped {
+ get {
+ return base.Untyped;
+ }
+ set {
+ base.Untyped = value;
+ this.ContentField.Untyped = value;
+ }
+ }
+
+ public new virtual purl.org.dc.elementsQualified.SimpleLiteral Content {
+ get {
+ return ContentField;
+ }
+ }
+
+ private void SetInnerType(purl.org.dc.elementsQualified.SimpleLiteral ContentField) {
+ this.ContentField = ((purl.org.dc.elementsQualified.SimpleLiteral)(XTypedServices.GetCloneIfRooted(ContentField)));
+ XTypedServices.SetName(this, this.ContentField);
+ base.SetSubstitutionMember(ContentField);
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public source(purl.org.dc.elementsQualified.SimpleLiteral content) :
+ base(true) {
+ SetInnerType(content);
+ }
+
+ private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("source", "http://purl.org/dc/terms/");
+
+ Dictionary IXMetaData.LocalElementsDictionary {
+ get {
+ IXMetaData schemaMetaData = ((IXMetaData)(this.Content));
+ return schemaMetaData.LocalElementsDictionary;
+ }
+ }
+
+ XTypedElement IXMetaData.Content {
+ get {
+ return this.Content;
+ }
+ }
+
+ ContentModelEntity IXMetaData.GetContentModel() {
+ return ContentModelEntity.Default;
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ System.Xml.Linq.XName IXMetaData.SchemaName {
+ get {
+ return xName;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ SchemaOrigin IXMetaData.TypeOrigin {
+ get {
+ return SchemaOrigin.Element;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ ILinqToXsdTypeManager IXMetaData.TypeManager {
+ get {
+ return LinqToXsdTypeManager.Instance;
+ }
+ }
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public partial class language : global::purl.org.dc.elementsQualified.language, IXMetaData {
+
+ public new static language Load(string xmlFile) {
+ return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance);
+ }
+
+ public static language Load(System.IO.TextReader xmlFile) {
+ return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance);
+ }
+
+ public new static language Parse(string xml) {
+ return XTypedServices.Parse(xml, LinqToXsdTypeManager.Instance);
+ }
+
+ public static explicit operator language(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
+
+ public override XTypedElement Clone() {
+ return new language(((purl.org.dc.elementsQualified.SimpleLiteral)(this.Content.Clone())));
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ private purl.org.dc.elementsQualified.SimpleLiteral ContentField;
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public language() :
+ base(true) {
+ SetInnerType(new purl.org.dc.elementsQualified.SimpleLiteral());
+ }
+
+ public override XElement Untyped {
+ get {
+ return base.Untyped;
+ }
+ set {
+ base.Untyped = value;
+ this.ContentField.Untyped = value;
+ }
+ }
+
+ public new virtual purl.org.dc.elementsQualified.SimpleLiteral Content {
+ get {
+ return ContentField;
+ }
+ }
+
+ private void SetInnerType(purl.org.dc.elementsQualified.SimpleLiteral ContentField) {
+ this.ContentField = ((purl.org.dc.elementsQualified.SimpleLiteral)(XTypedServices.GetCloneIfRooted(ContentField)));
+ XTypedServices.SetName(this, this.ContentField);
+ base.SetSubstitutionMember(ContentField);
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public language(purl.org.dc.elementsQualified.SimpleLiteral content) :
+ base(true) {
+ SetInnerType(content);
+ }
+
+ private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("language", "http://purl.org/dc/terms/");
+
+ Dictionary IXMetaData.LocalElementsDictionary {
+ get {
+ IXMetaData schemaMetaData = ((IXMetaData)(this.Content));
+ return schemaMetaData.LocalElementsDictionary;
+ }
+ }
+
+ XTypedElement IXMetaData.Content {
+ get {
+ return this.Content;
+ }
+ }
+
+ ContentModelEntity IXMetaData.GetContentModel() {
+ return ContentModelEntity.Default;
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ System.Xml.Linq.XName IXMetaData.SchemaName {
+ get {
+ return xName;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ SchemaOrigin IXMetaData.TypeOrigin {
+ get {
+ return SchemaOrigin.Element;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ ILinqToXsdTypeManager IXMetaData.TypeManager {
+ get {
+ return LinqToXsdTypeManager.Instance;
+ }
+ }
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public partial class relation : global::purl.org.dc.elementsQualified.relation, IXMetaData {
+
+ public new static relation Load(string xmlFile) {
+ return ((relation)(XTypedServices.ToXTypedElement(XElement.Load(xmlFile), LinqToXsdTypeManager.Instance)));
+ }
+
+ public static relation Load(System.IO.TextReader xmlFile) {
+ return ((relation)(XTypedServices.ToXTypedElement(XElement.Load(xmlFile), LinqToXsdTypeManager.Instance)));
+ }
+
+ public new static relation Parse(string xml) {
+ return ((relation)(XTypedServices.ToXTypedElement(XElement.Parse(xml), LinqToXsdTypeManager.Instance)));
+ }
+
+ public static explicit operator relation(XElement xe) { return (relation)XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
+
+ public override XTypedElement Clone() {
+ return new relation(((purl.org.dc.elementsQualified.SimpleLiteral)(this.Content.Clone())));
+ }
+
+ protected relation(bool setNull) :
+ base(true) {
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ private purl.org.dc.elementsQualified.SimpleLiteral ContentField;
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public relation() :
+ base(true) {
+ SetInnerType(new purl.org.dc.elementsQualified.SimpleLiteral());
+ }
+
+ public override XElement Untyped {
+ get {
+ return base.Untyped;
+ }
+ set {
+ base.Untyped = value;
+ if ((this.ContentField != null)) {
+ this.ContentField.Untyped = value;
+ }
+ }
+ }
+
+ public new virtual purl.org.dc.elementsQualified.SimpleLiteral Content {
+ get {
+ return ContentField;
+ }
+ }
+
+ private void SetInnerType(purl.org.dc.elementsQualified.SimpleLiteral ContentField) {
+ this.ContentField = ((purl.org.dc.elementsQualified.SimpleLiteral)(XTypedServices.GetCloneIfRooted(ContentField)));
+ XTypedServices.SetName(this, this.ContentField);
+ base.SetSubstitutionMember(ContentField);
+ }
+
+ protected virtual void SetSubstitutionMember(purl.org.dc.elementsQualified.SimpleLiteral ContentField) {
+ this.ContentField = ContentField;
+ base.SetSubstitutionMember(ContentField);
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public relation(purl.org.dc.elementsQualified.SimpleLiteral content) :
+ base(true) {
+ SetInnerType(content);
+ }
+
+ private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("relation", "http://purl.org/dc/terms/");
+
+ Dictionary IXMetaData.LocalElementsDictionary {
+ get {
+ IXMetaData schemaMetaData = ((IXMetaData)(this.Content));
+ return schemaMetaData.LocalElementsDictionary;
+ }
+ }
+
+ XTypedElement IXMetaData.Content {
+ get {
+ return this.Content;
+ }
+ }
+
+ ContentModelEntity IXMetaData.GetContentModel() {
+ return ContentModelEntity.Default;
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ System.Xml.Linq.XName IXMetaData.SchemaName {
+ get {
+ return xName;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ SchemaOrigin IXMetaData.TypeOrigin {
+ get {
+ return SchemaOrigin.Element;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ ILinqToXsdTypeManager IXMetaData.TypeManager {
+ get {
+ return LinqToXsdTypeManager.Instance;
+ }
+ }
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public partial class coverage : global::purl.org.dc.elementsQualified.coverage, IXMetaData {
+
+ public new static coverage Load(string xmlFile) {
+ return ((coverage)(XTypedServices.ToXTypedElement(XElement.Load(xmlFile), LinqToXsdTypeManager.Instance)));
+ }
+
+ public static coverage Load(System.IO.TextReader xmlFile) {
+ return ((coverage)(XTypedServices.ToXTypedElement(XElement.Load(xmlFile), LinqToXsdTypeManager.Instance)));
+ }
+
+ public new static coverage Parse(string xml) {
+ return ((coverage)(XTypedServices.ToXTypedElement(XElement.Parse(xml), LinqToXsdTypeManager.Instance)));
+ }
+
+ public static explicit operator coverage(XElement xe) { return (coverage)XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
+
+ public override XTypedElement Clone() {
+ return new coverage(((purl.org.dc.elementsQualified.SimpleLiteral)(this.Content.Clone())));
+ }
+
+ protected coverage(bool setNull) :
+ base(true) {
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ private purl.org.dc.elementsQualified.SimpleLiteral ContentField;
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public coverage() :
+ base(true) {
+ SetInnerType(new purl.org.dc.elementsQualified.SimpleLiteral());
+ }
+
+ public override XElement Untyped {
+ get {
+ return base.Untyped;
+ }
+ set {
+ base.Untyped = value;
+ if ((this.ContentField != null)) {
+ this.ContentField.Untyped = value;
+ }
+ }
+ }
+
+ public new virtual purl.org.dc.elementsQualified.SimpleLiteral Content {
+ get {
+ return ContentField;
+ }
+ }
+
+ private void SetInnerType(purl.org.dc.elementsQualified.SimpleLiteral ContentField) {
+ this.ContentField = ((purl.org.dc.elementsQualified.SimpleLiteral)(XTypedServices.GetCloneIfRooted(ContentField)));
+ XTypedServices.SetName(this, this.ContentField);
+ base.SetSubstitutionMember(ContentField);
+ }
+
+ protected virtual void SetSubstitutionMember(purl.org.dc.elementsQualified.SimpleLiteral ContentField) {
+ this.ContentField = ContentField;
+ base.SetSubstitutionMember(ContentField);
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public coverage(purl.org.dc.elementsQualified.SimpleLiteral content) :
+ base(true) {
+ SetInnerType(content);
+ }
+
+ private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("coverage", "http://purl.org/dc/terms/");
+
+ Dictionary IXMetaData.LocalElementsDictionary {
+ get {
+ IXMetaData schemaMetaData = ((IXMetaData)(this.Content));
+ return schemaMetaData.LocalElementsDictionary;
+ }
+ }
+
+ XTypedElement IXMetaData.Content {
+ get {
+ return this.Content;
+ }
+ }
+
+ ContentModelEntity IXMetaData.GetContentModel() {
+ return ContentModelEntity.Default;
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ System.Xml.Linq.XName IXMetaData.SchemaName {
+ get {
+ return xName;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ SchemaOrigin IXMetaData.TypeOrigin {
+ get {
+ return SchemaOrigin.Element;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ ILinqToXsdTypeManager IXMetaData.TypeManager {
+ get {
+ return LinqToXsdTypeManager.Instance;
+ }
+ }
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public partial class rights : global::purl.org.dc.elementsQualified.rights, IXMetaData {
+
+ public new static rights Load(string xmlFile) {
+ return ((rights)(XTypedServices.ToXTypedElement(XElement.Load(xmlFile), LinqToXsdTypeManager.Instance)));
+ }
+
+ public static rights Load(System.IO.TextReader xmlFile) {
+ return ((rights)(XTypedServices.ToXTypedElement(XElement.Load(xmlFile), LinqToXsdTypeManager.Instance)));
+ }
+
+ public new static rights Parse(string xml) {
+ return ((rights)(XTypedServices.ToXTypedElement(XElement.Parse(xml), LinqToXsdTypeManager.Instance)));
+ }
+
+ public static explicit operator rights(XElement xe) { return (rights)XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
+
+ public override XTypedElement Clone() {
+ return new rights(((purl.org.dc.elementsQualified.SimpleLiteral)(this.Content.Clone())));
+ }
+
+ protected rights(bool setNull) :
+ base(true) {
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ private purl.org.dc.elementsQualified.SimpleLiteral ContentField;
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public rights() :
+ base(true) {
+ SetInnerType(new purl.org.dc.elementsQualified.SimpleLiteral());
+ }
+
+ public override XElement Untyped {
+ get {
+ return base.Untyped;
+ }
+ set {
+ base.Untyped = value;
+ if ((this.ContentField != null)) {
+ this.ContentField.Untyped = value;
+ }
+ }
+ }
+
+ public new virtual purl.org.dc.elementsQualified.SimpleLiteral Content {
+ get {
+ return ContentField;
+ }
+ }
+
+ private void SetInnerType(purl.org.dc.elementsQualified.SimpleLiteral ContentField) {
+ this.ContentField = ((purl.org.dc.elementsQualified.SimpleLiteral)(XTypedServices.GetCloneIfRooted(ContentField)));
+ XTypedServices.SetName(this, this.ContentField);
+ base.SetSubstitutionMember(ContentField);
+ }
+
+ protected virtual void SetSubstitutionMember(purl.org.dc.elementsQualified.SimpleLiteral ContentField) {
+ this.ContentField = ContentField;
+ base.SetSubstitutionMember(ContentField);
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public rights(purl.org.dc.elementsQualified.SimpleLiteral content) :
+ base(true) {
+ SetInnerType(content);
+ }
+
+ private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("rights", "http://purl.org/dc/terms/");
+
+ Dictionary IXMetaData.LocalElementsDictionary {
+ get {
+ IXMetaData schemaMetaData = ((IXMetaData)(this.Content));
+ return schemaMetaData.LocalElementsDictionary;
+ }
+ }
+
+ XTypedElement IXMetaData.Content {
+ get {
+ return this.Content;
+ }
+ }
+
+ ContentModelEntity IXMetaData.GetContentModel() {
+ return ContentModelEntity.Default;
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ System.Xml.Linq.XName IXMetaData.SchemaName {
+ get {
+ return xName;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ SchemaOrigin IXMetaData.TypeOrigin {
+ get {
+ return SchemaOrigin.Element;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ ILinqToXsdTypeManager IXMetaData.TypeManager {
+ get {
+ return LinqToXsdTypeManager.Instance;
+ }
+ }
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public partial class alternative : global::purl.org.dc.termsQualified.title, IXMetaData {
+
+ public new static alternative Load(string xmlFile) {
+ return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance);
+ }
+
+ public static alternative Load(System.IO.TextReader xmlFile) {
+ return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance);
+ }
+
+ public new static alternative Parse(string xml) {
+ return XTypedServices.Parse(xml, LinqToXsdTypeManager.Instance);
+ }
+
+ public static explicit operator alternative(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
+
+ public override XTypedElement Clone() {
+ return new alternative(((purl.org.dc.elementsQualified.SimpleLiteral)(this.Content.Clone())));
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ private purl.org.dc.elementsQualified.SimpleLiteral ContentField;
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public alternative() :
+ base(true) {
+ SetInnerType(new purl.org.dc.elementsQualified.SimpleLiteral());
+ }
+
+ public override XElement Untyped {
+ get {
+ return base.Untyped;
+ }
+ set {
+ base.Untyped = value;
+ this.ContentField.Untyped = value;
+ }
+ }
+
+ public new virtual purl.org.dc.elementsQualified.SimpleLiteral Content {
+ get {
+ return ContentField;
+ }
+ }
+
+ private void SetInnerType(purl.org.dc.elementsQualified.SimpleLiteral ContentField) {
+ this.ContentField = ((purl.org.dc.elementsQualified.SimpleLiteral)(XTypedServices.GetCloneIfRooted(ContentField)));
+ XTypedServices.SetName(this, this.ContentField);
+ base.SetSubstitutionMember(ContentField);
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public alternative(purl.org.dc.elementsQualified.SimpleLiteral content) :
+ base(true) {
+ SetInnerType(content);
+ }
+
+ private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("alternative", "http://purl.org/dc/terms/");
+
+ Dictionary IXMetaData.LocalElementsDictionary {
+ get {
+ IXMetaData schemaMetaData = ((IXMetaData)(this.Content));
+ return schemaMetaData.LocalElementsDictionary;
+ }
+ }
+
+ XTypedElement IXMetaData.Content {
+ get {
+ return this.Content;
+ }
+ }
+
+ ContentModelEntity IXMetaData.GetContentModel() {
+ return ContentModelEntity.Default;
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ System.Xml.Linq.XName IXMetaData.SchemaName {
+ get {
+ return xName;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ SchemaOrigin IXMetaData.TypeOrigin {
+ get {
+ return SchemaOrigin.Element;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ ILinqToXsdTypeManager IXMetaData.TypeManager {
+ get {
+ return LinqToXsdTypeManager.Instance;
+ }
+ }
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public partial class tableOfContents : global::purl.org.dc.termsQualified.description, IXMetaData {
+
+ public new static tableOfContents Load(string xmlFile) {
+ return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance);
+ }
+
+ public static tableOfContents Load(System.IO.TextReader xmlFile) {
+ return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance);
+ }
+
+ public new static tableOfContents Parse(string xml) {
+ return XTypedServices.Parse(xml, LinqToXsdTypeManager.Instance);
+ }
+
+ public static explicit operator tableOfContents(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
+
+ public override XTypedElement Clone() {
+ return new tableOfContents(((purl.org.dc.elementsQualified.SimpleLiteral)(this.Content.Clone())));
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ private purl.org.dc.elementsQualified.SimpleLiteral ContentField;
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public tableOfContents() :
+ base(true) {
+ SetInnerType(new purl.org.dc.elementsQualified.SimpleLiteral());
+ }
+
+ public override XElement Untyped {
+ get {
+ return base.Untyped;
+ }
+ set {
+ base.Untyped = value;
+ this.ContentField.Untyped = value;
+ }
+ }
+
+ public new virtual purl.org.dc.elementsQualified.SimpleLiteral Content {
+ get {
+ return ContentField;
+ }
+ }
+
+ private void SetInnerType(purl.org.dc.elementsQualified.SimpleLiteral ContentField) {
+ this.ContentField = ((purl.org.dc.elementsQualified.SimpleLiteral)(XTypedServices.GetCloneIfRooted(ContentField)));
+ XTypedServices.SetName(this, this.ContentField);
+ base.SetSubstitutionMember(ContentField);
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public tableOfContents(purl.org.dc.elementsQualified.SimpleLiteral content) :
+ base(true) {
+ SetInnerType(content);
+ }
+
+ private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("tableOfContents", "http://purl.org/dc/terms/");
+
+ Dictionary IXMetaData.LocalElementsDictionary {
+ get {
+ IXMetaData schemaMetaData = ((IXMetaData)(this.Content));
+ return schemaMetaData.LocalElementsDictionary;
+ }
+ }
+
+ XTypedElement IXMetaData.Content {
+ get {
+ return this.Content;
+ }
+ }
+
+ ContentModelEntity IXMetaData.GetContentModel() {
+ return ContentModelEntity.Default;
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ System.Xml.Linq.XName IXMetaData.SchemaName {
+ get {
+ return xName;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ SchemaOrigin IXMetaData.TypeOrigin {
+ get {
+ return SchemaOrigin.Element;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ ILinqToXsdTypeManager IXMetaData.TypeManager {
+ get {
+ return LinqToXsdTypeManager.Instance;
+ }
+ }
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public partial class @abstract : global::purl.org.dc.termsQualified.description, IXMetaData {
+
+ public new static @abstract Load(string xmlFile) {
+ return XTypedServices.Load<@abstract, purl.org.dc.elementsQualified.SimpleLiteral>(xmlFile, LinqToXsdTypeManager.Instance);
+ }
+
+ public static @abstract Load(System.IO.TextReader xmlFile) {
+ return XTypedServices.Load<@abstract, purl.org.dc.elementsQualified.SimpleLiteral>(xmlFile, LinqToXsdTypeManager.Instance);
+ }
+
+ public new static @abstract Parse(string xml) {
+ return XTypedServices.Parse<@abstract, purl.org.dc.elementsQualified.SimpleLiteral>(xml, LinqToXsdTypeManager.Instance);
+ }
+
+ public static explicit operator @abstract(XElement xe) { return XTypedServices.ToXTypedElement<@abstract, purl.org.dc.elementsQualified.SimpleLiteral>(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
+
+ public override XTypedElement Clone() {
+ return new @abstract(((purl.org.dc.elementsQualified.SimpleLiteral)(this.Content.Clone())));
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ private purl.org.dc.elementsQualified.SimpleLiteral ContentField;
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public @abstract() :
+ base(true) {
+ SetInnerType(new purl.org.dc.elementsQualified.SimpleLiteral());
+ }
+
+ public override XElement Untyped {
+ get {
+ return base.Untyped;
+ }
+ set {
+ base.Untyped = value;
+ this.ContentField.Untyped = value;
+ }
+ }
+
+ public new virtual purl.org.dc.elementsQualified.SimpleLiteral Content {
+ get {
+ return ContentField;
+ }
+ }
+
+ private void SetInnerType(purl.org.dc.elementsQualified.SimpleLiteral ContentField) {
+ this.ContentField = ((purl.org.dc.elementsQualified.SimpleLiteral)(XTypedServices.GetCloneIfRooted(ContentField)));
+ XTypedServices.SetName(this, this.ContentField);
+ base.SetSubstitutionMember(ContentField);
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public @abstract(purl.org.dc.elementsQualified.SimpleLiteral content) :
+ base(true) {
+ SetInnerType(content);
+ }
+
+ private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("abstract", "http://purl.org/dc/terms/");
+
+ Dictionary IXMetaData.LocalElementsDictionary {
+ get {
+ IXMetaData schemaMetaData = ((IXMetaData)(this.Content));
+ return schemaMetaData.LocalElementsDictionary;
+ }
+ }
+
+ XTypedElement IXMetaData.Content {
+ get {
+ return this.Content;
+ }
+ }
+
+ ContentModelEntity IXMetaData.GetContentModel() {
+ return ContentModelEntity.Default;
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ System.Xml.Linq.XName IXMetaData.SchemaName {
+ get {
+ return xName;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ SchemaOrigin IXMetaData.TypeOrigin {
+ get {
+ return SchemaOrigin.Element;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ ILinqToXsdTypeManager IXMetaData.TypeManager {
+ get {
+ return LinqToXsdTypeManager.Instance;
+ }
+ }
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public partial class created : global::purl.org.dc.termsQualified.date, IXMetaData {
+
+ public new static created Load(string xmlFile) {
+ return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance);
+ }
+
+ public static created Load(System.IO.TextReader xmlFile) {
+ return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance);
+ }
+
+ public new static created Parse(string xml) {
+ return XTypedServices.Parse(xml, LinqToXsdTypeManager.Instance);
+ }
+
+ public static explicit operator created(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
+
+ public override XTypedElement Clone() {
+ return new created(((purl.org.dc.elementsQualified.SimpleLiteral)(this.Content.Clone())));
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ private purl.org.dc.elementsQualified.SimpleLiteral ContentField;
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public created() :
+ base(true) {
+ SetInnerType(new purl.org.dc.elementsQualified.SimpleLiteral());
+ }
+
+ public override XElement Untyped {
+ get {
+ return base.Untyped;
+ }
+ set {
+ base.Untyped = value;
+ this.ContentField.Untyped = value;
+ }
+ }
+
+ public new virtual purl.org.dc.elementsQualified.SimpleLiteral Content {
+ get {
+ return ContentField;
+ }
+ }
+
+ private void SetInnerType(purl.org.dc.elementsQualified.SimpleLiteral ContentField) {
+ this.ContentField = ((purl.org.dc.elementsQualified.SimpleLiteral)(XTypedServices.GetCloneIfRooted(ContentField)));
+ XTypedServices.SetName(this, this.ContentField);
+ base.SetSubstitutionMember(ContentField);
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public created(purl.org.dc.elementsQualified.SimpleLiteral content) :
+ base(true) {
+ SetInnerType(content);
+ }
+
+ private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("created", "http://purl.org/dc/terms/");
+
+ Dictionary IXMetaData.LocalElementsDictionary {
+ get {
+ IXMetaData schemaMetaData = ((IXMetaData)(this.Content));
+ return schemaMetaData.LocalElementsDictionary;
+ }
+ }
+
+ XTypedElement IXMetaData.Content {
+ get {
+ return this.Content;
+ }
+ }
+
+ ContentModelEntity IXMetaData.GetContentModel() {
+ return ContentModelEntity.Default;
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ System.Xml.Linq.XName IXMetaData.SchemaName {
+ get {
+ return xName;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ SchemaOrigin IXMetaData.TypeOrigin {
+ get {
+ return SchemaOrigin.Element;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ ILinqToXsdTypeManager IXMetaData.TypeManager {
+ get {
+ return LinqToXsdTypeManager.Instance;
+ }
+ }
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public partial class valid : global::purl.org.dc.termsQualified.date, IXMetaData {
+
+ public new static valid Load(string xmlFile) {
+ return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance);
+ }
+
+ public static valid Load(System.IO.TextReader xmlFile) {
+ return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance);
+ }
+
+ public new static valid Parse(string xml) {
+ return XTypedServices.Parse(xml, LinqToXsdTypeManager.Instance);
+ }
+
+ public static explicit operator valid(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
+
+ public override XTypedElement Clone() {
+ return new valid(((purl.org.dc.elementsQualified.SimpleLiteral)(this.Content.Clone())));
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ private purl.org.dc.elementsQualified.SimpleLiteral ContentField;
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public valid() :
+ base(true) {
+ SetInnerType(new purl.org.dc.elementsQualified.SimpleLiteral());
+ }
+
+ public override XElement Untyped {
+ get {
+ return base.Untyped;
+ }
+ set {
+ base.Untyped = value;
+ this.ContentField.Untyped = value;
+ }
+ }
+
+ public new virtual purl.org.dc.elementsQualified.SimpleLiteral Content {
+ get {
+ return ContentField;
+ }
+ }
+
+ private void SetInnerType(purl.org.dc.elementsQualified.SimpleLiteral ContentField) {
+ this.ContentField = ((purl.org.dc.elementsQualified.SimpleLiteral)(XTypedServices.GetCloneIfRooted(ContentField)));
+ XTypedServices.SetName(this, this.ContentField);
+ base.SetSubstitutionMember(ContentField);
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public valid(purl.org.dc.elementsQualified.SimpleLiteral content) :
+ base(true) {
+ SetInnerType(content);
+ }
+
+ private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("valid", "http://purl.org/dc/terms/");
+
+ Dictionary IXMetaData.LocalElementsDictionary {
+ get {
+ IXMetaData schemaMetaData = ((IXMetaData)(this.Content));
+ return schemaMetaData.LocalElementsDictionary;
+ }
+ }
+
+ XTypedElement IXMetaData.Content {
+ get {
+ return this.Content;
+ }
+ }
+
+ ContentModelEntity IXMetaData.GetContentModel() {
+ return ContentModelEntity.Default;
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ System.Xml.Linq.XName IXMetaData.SchemaName {
+ get {
+ return xName;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ SchemaOrigin IXMetaData.TypeOrigin {
+ get {
+ return SchemaOrigin.Element;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ ILinqToXsdTypeManager IXMetaData.TypeManager {
+ get {
+ return LinqToXsdTypeManager.Instance;
+ }
+ }
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public partial class available : global::purl.org.dc.termsQualified.date, IXMetaData {
+
+ public new static available Load(string xmlFile) {
+ return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance);
+ }
+
+ public static available Load(System.IO.TextReader xmlFile) {
+ return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance);
+ }
+
+ public new static available Parse(string xml) {
+ return XTypedServices.Parse(xml, LinqToXsdTypeManager.Instance);
+ }
+
+ public static explicit operator available(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
+
+ public override XTypedElement Clone() {
+ return new available(((purl.org.dc.elementsQualified.SimpleLiteral)(this.Content.Clone())));
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ private purl.org.dc.elementsQualified.SimpleLiteral ContentField;
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public available() :
+ base(true) {
+ SetInnerType(new purl.org.dc.elementsQualified.SimpleLiteral());
+ }
+
+ public override XElement Untyped {
+ get {
+ return base.Untyped;
+ }
+ set {
+ base.Untyped = value;
+ this.ContentField.Untyped = value;
+ }
+ }
+
+ public new virtual purl.org.dc.elementsQualified.SimpleLiteral Content {
+ get {
+ return ContentField;
+ }
+ }
+
+ private void SetInnerType(purl.org.dc.elementsQualified.SimpleLiteral ContentField) {
+ this.ContentField = ((purl.org.dc.elementsQualified.SimpleLiteral)(XTypedServices.GetCloneIfRooted(ContentField)));
+ XTypedServices.SetName(this, this.ContentField);
+ base.SetSubstitutionMember(ContentField);
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public available(purl.org.dc.elementsQualified.SimpleLiteral content) :
+ base(true) {
+ SetInnerType(content);
+ }
+
+ private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("available", "http://purl.org/dc/terms/");
+
+ Dictionary IXMetaData.LocalElementsDictionary {
+ get {
+ IXMetaData schemaMetaData = ((IXMetaData)(this.Content));
+ return schemaMetaData.LocalElementsDictionary;
+ }
+ }
+
+ XTypedElement IXMetaData.Content {
+ get {
+ return this.Content;
+ }
+ }
+
+ ContentModelEntity IXMetaData.GetContentModel() {
+ return ContentModelEntity.Default;
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ System.Xml.Linq.XName IXMetaData.SchemaName {
+ get {
+ return xName;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ SchemaOrigin IXMetaData.TypeOrigin {
+ get {
+ return SchemaOrigin.Element;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ ILinqToXsdTypeManager IXMetaData.TypeManager {
+ get {
+ return LinqToXsdTypeManager.Instance;
+ }
+ }
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public partial class issued : global::purl.org.dc.termsQualified.date, IXMetaData {
+
+ public new static issued Load(string xmlFile) {
+ return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance);
+ }
+
+ public static issued Load(System.IO.TextReader xmlFile) {
+ return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance);
+ }
+
+ public new static issued Parse(string xml) {
+ return XTypedServices.Parse(xml, LinqToXsdTypeManager.Instance);
+ }
+
+ public static explicit operator issued(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
+
+ public override XTypedElement Clone() {
+ return new issued(((purl.org.dc.elementsQualified.SimpleLiteral)(this.Content.Clone())));
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ private purl.org.dc.elementsQualified.SimpleLiteral ContentField;
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public issued() :
+ base(true) {
+ SetInnerType(new purl.org.dc.elementsQualified.SimpleLiteral());
+ }
+
+ public override XElement Untyped {
+ get {
+ return base.Untyped;
+ }
+ set {
+ base.Untyped = value;
+ this.ContentField.Untyped = value;
+ }
+ }
+
+ public new virtual purl.org.dc.elementsQualified.SimpleLiteral Content {
+ get {
+ return ContentField;
+ }
+ }
+
+ private void SetInnerType(purl.org.dc.elementsQualified.SimpleLiteral ContentField) {
+ this.ContentField = ((purl.org.dc.elementsQualified.SimpleLiteral)(XTypedServices.GetCloneIfRooted(ContentField)));
+ XTypedServices.SetName(this, this.ContentField);
+ base.SetSubstitutionMember(ContentField);
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public issued(purl.org.dc.elementsQualified.SimpleLiteral content) :
+ base(true) {
+ SetInnerType(content);
+ }
+
+ private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("issued", "http://purl.org/dc/terms/");
+
+ Dictionary IXMetaData.LocalElementsDictionary {
+ get {
+ IXMetaData schemaMetaData = ((IXMetaData)(this.Content));
+ return schemaMetaData.LocalElementsDictionary;
+ }
+ }
+
+ XTypedElement IXMetaData.Content {
+ get {
+ return this.Content;
+ }
+ }
+
+ ContentModelEntity IXMetaData.GetContentModel() {
+ return ContentModelEntity.Default;
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ System.Xml.Linq.XName IXMetaData.SchemaName {
+ get {
+ return xName;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ SchemaOrigin IXMetaData.TypeOrigin {
+ get {
+ return SchemaOrigin.Element;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ ILinqToXsdTypeManager IXMetaData.TypeManager {
+ get {
+ return LinqToXsdTypeManager.Instance;
+ }
+ }
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public partial class modified : global::purl.org.dc.termsQualified.date, IXMetaData {
+
+ public new static modified Load(string xmlFile) {
+ return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance);
+ }
+
+ public static modified Load(System.IO.TextReader xmlFile) {
+ return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance);
+ }
+
+ public new static modified Parse(string xml) {
+ return XTypedServices.Parse(xml, LinqToXsdTypeManager.Instance);
+ }
+
+ public static explicit operator modified(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
+
+ public override XTypedElement Clone() {
+ return new modified(((purl.org.dc.elementsQualified.SimpleLiteral)(this.Content.Clone())));
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ private purl.org.dc.elementsQualified.SimpleLiteral ContentField;
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public modified() :
+ base(true) {
+ SetInnerType(new purl.org.dc.elementsQualified.SimpleLiteral());
+ }
+
+ public override XElement Untyped {
+ get {
+ return base.Untyped;
+ }
+ set {
+ base.Untyped = value;
+ this.ContentField.Untyped = value;
+ }
+ }
+
+ public new virtual purl.org.dc.elementsQualified.SimpleLiteral Content {
+ get {
+ return ContentField;
+ }
+ }
+
+ private void SetInnerType(purl.org.dc.elementsQualified.SimpleLiteral ContentField) {
+ this.ContentField = ((purl.org.dc.elementsQualified.SimpleLiteral)(XTypedServices.GetCloneIfRooted(ContentField)));
+ XTypedServices.SetName(this, this.ContentField);
+ base.SetSubstitutionMember(ContentField);
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public modified(purl.org.dc.elementsQualified.SimpleLiteral content) :
+ base(true) {
+ SetInnerType(content);
+ }
+
+ private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("modified", "http://purl.org/dc/terms/");
+
+ Dictionary IXMetaData.LocalElementsDictionary {
+ get {
+ IXMetaData schemaMetaData = ((IXMetaData)(this.Content));
+ return schemaMetaData.LocalElementsDictionary;
+ }
+ }
+
+ XTypedElement IXMetaData.Content {
+ get {
+ return this.Content;
+ }
+ }
+
+ ContentModelEntity IXMetaData.GetContentModel() {
+ return ContentModelEntity.Default;
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ System.Xml.Linq.XName IXMetaData.SchemaName {
+ get {
+ return xName;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ SchemaOrigin IXMetaData.TypeOrigin {
+ get {
+ return SchemaOrigin.Element;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ ILinqToXsdTypeManager IXMetaData.TypeManager {
+ get {
+ return LinqToXsdTypeManager.Instance;
+ }
+ }
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public partial class dateAccepted : global::purl.org.dc.termsQualified.date, IXMetaData {
+
+ public new static dateAccepted Load(string xmlFile) {
+ return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance);
+ }
+
+ public static dateAccepted Load(System.IO.TextReader xmlFile) {
+ return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance);
+ }
+
+ public new static dateAccepted Parse(string xml) {
+ return XTypedServices.Parse(xml, LinqToXsdTypeManager.Instance);
+ }
+
+ public static explicit operator dateAccepted(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
+
+ public override XTypedElement Clone() {
+ return new dateAccepted(((purl.org.dc.elementsQualified.SimpleLiteral)(this.Content.Clone())));
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ private purl.org.dc.elementsQualified.SimpleLiteral ContentField;
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public dateAccepted() :
+ base(true) {
+ SetInnerType(new purl.org.dc.elementsQualified.SimpleLiteral());
+ }
+
+ public override XElement Untyped {
+ get {
+ return base.Untyped;
+ }
+ set {
+ base.Untyped = value;
+ this.ContentField.Untyped = value;
+ }
+ }
+
+ public new virtual purl.org.dc.elementsQualified.SimpleLiteral Content {
+ get {
+ return ContentField;
+ }
+ }
+
+ private void SetInnerType(purl.org.dc.elementsQualified.SimpleLiteral ContentField) {
+ this.ContentField = ((purl.org.dc.elementsQualified.SimpleLiteral)(XTypedServices.GetCloneIfRooted(ContentField)));
+ XTypedServices.SetName(this, this.ContentField);
+ base.SetSubstitutionMember(ContentField);
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public dateAccepted(purl.org.dc.elementsQualified.SimpleLiteral content) :
+ base(true) {
+ SetInnerType(content);
+ }
+
+ private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("dateAccepted", "http://purl.org/dc/terms/");
+
+ Dictionary IXMetaData.LocalElementsDictionary {
+ get {
+ IXMetaData schemaMetaData = ((IXMetaData)(this.Content));
+ return schemaMetaData.LocalElementsDictionary;
+ }
+ }
+
+ XTypedElement IXMetaData.Content {
+ get {
+ return this.Content;
+ }
+ }
+
+ ContentModelEntity IXMetaData.GetContentModel() {
+ return ContentModelEntity.Default;
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ System.Xml.Linq.XName IXMetaData.SchemaName {
+ get {
+ return xName;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ SchemaOrigin IXMetaData.TypeOrigin {
+ get {
+ return SchemaOrigin.Element;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ ILinqToXsdTypeManager IXMetaData.TypeManager {
+ get {
+ return LinqToXsdTypeManager.Instance;
+ }
+ }
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public partial class dateCopyrighted : global::purl.org.dc.termsQualified.date, IXMetaData {
+
+ public new static dateCopyrighted Load(string xmlFile) {
+ return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance);
+ }
+
+ public static dateCopyrighted Load(System.IO.TextReader xmlFile) {
+ return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance);
+ }
+
+ public new static dateCopyrighted Parse(string xml) {
+ return XTypedServices.Parse(xml, LinqToXsdTypeManager.Instance);
+ }
+
+ public static explicit operator dateCopyrighted(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); }
+
+ public override XTypedElement Clone() {
+ return new dateCopyrighted(((purl.org.dc.elementsQualified.SimpleLiteral)(this.Content.Clone())));
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ private purl.org.dc.elementsQualified.SimpleLiteral ContentField;
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public dateCopyrighted() :
+ base(true) {
+ SetInnerType(new purl.org.dc.elementsQualified.SimpleLiteral());
+ }
+
+ public override XElement Untyped {
+ get {
+ return base.Untyped;
+ }
+ set {
+ base.Untyped = value;
+ this.ContentField.Untyped = value;
+ }
+ }
+
+ public new virtual purl.org.dc.elementsQualified.SimpleLiteral Content {
+ get {
+ return ContentField;
+ }
+ }
+
+ private void SetInnerType(purl.org.dc.elementsQualified.SimpleLiteral ContentField) {
+ this.ContentField = ((purl.org.dc.elementsQualified.SimpleLiteral)(XTypedServices.GetCloneIfRooted(ContentField)));
+ XTypedServices.SetName(this, this.ContentField);
+ base.SetSubstitutionMember(ContentField);
+ }
+
+ ///
+ ///
+ ///
+ /// This is the default type for all of the DC elements.
+ /// It permits text content only with optional
+ /// xml:lang attribute.
+ /// Text is allowed because mixed="true", but sub-elements
+ /// are disallowed because minOccurs="0" and maxOccurs="0"
+ /// are on the xs:any tag.
+ ///
+ /// This complexType allows for restriction or extension permitting
+ /// child elements.
+ ///
+ ///
+ ///
+ public dateCopyrighted(purl.org.dc.elementsQualified.SimpleLiteral content) :
+ base(true) {
+ SetInnerType(content);
+ }
+
+ private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("dateCopyrighted", "http://purl.org/dc/terms/");
+
+ Dictionary IXMetaData.LocalElementsDictionary {
+ get {
+ IXMetaData schemaMetaData = ((IXMetaData)(this.Content));
+ return schemaMetaData.LocalElementsDictionary;
+ }
+ }
+
+ XTypedElement IXMetaData.Content {
+ get {
+ return this.Content;
+ }
+ }
+
+ ContentModelEntity IXMetaData.GetContentModel() {
+ return ContentModelEntity.Default;
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ System.Xml.Linq.XName IXMetaData.SchemaName {
+ get {
+ return xName;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ SchemaOrigin IXMetaData.TypeOrigin {
+ get {
+ return SchemaOrigin.Element;
+ }
+ }
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+ ILinqToXsdTypeManager IXMetaData.TypeManager {
+ get {
+ return LinqToXsdTypeManager.Instance;
+ }
+ }
+ }
+
+ ///
+ ///