<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE rdf:RDF [
    <!ENTITY rdfns 'http://www.w3.org/1999/02/22-rdf-syntax-ns#'>
    <!ENTITY rdfsns 'http://www.w3.org/2000/01/rdf-schema#'>
    <!ENTITY dcns 'http://purl.org/dc/elements/1.1/'>
    <!ENTITY dctermsns 'http://purl.org/dc/terms/'>
    <!ENTITY dctypens 'http://purl.org/dc/dcmitype/'>
]>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="http://purl.org/dc/elements/1.1/">
<dc:title xml:lang="en-US">The Dublin Core Element Set v1.1 namespace providing access to its content by means of an RDF Schema</dc:title>
<dc:publisher xml:lang="en-US">The Dublin Core Metadata Initiative</dc:publisher>
<dc:description xml:lang="en-US">The Dublin Core Element Set v1.1 namespace provides URIs for the Dublin Core Elements v1.1. Entries are declared using RDF Schema language to support RDF applications.</dc:description>
<dc:language xml:lang="en-US">English</dc:language>
<dcterms:issued>1999-07-02</dcterms:issued>
<dcterms:modified>2003-03-24</dcterms:modified>
<dc:source rdf:resource="http://dublincore.org/documents/dces/"/>
<dc:source rdf:resource="http://dublincore.org/usage/decisions/"/>
<dcterms:isReferencedBy rdf:resource="http://www.dublincore.org/documents/2001/10/26/dcmi-namespace/"/>
<dcterms:isRequiredBy rdf:resource="http://purl.org/dc/terms/"/>
<dcterms:isReferencedBy rdf:resource="http://purl.org/dc/dcmitype/"/>
</rdf:Description>
<rdf:Property rdf:about="http://purl.org/dc/elements/1.1/title">
<rdfs:label xml:lang="en-US">Title</rdfs:label>
<rdfs:comment xml:lang="en-US">A name given to the resource.</rdfs:comment>
<dc:description xml:lang="en-US">Typically, a Title will be a name by which the resource is
		formally known.</dc:description>
<rdfs:isDefinedBy rdf:resource="http://purl.org/dc/elements/1.1/"/>
<dcterms:issued>1999-07-02</dcterms:issued>
<dcterms:modified>2002-10-04</dcterms:modified>
<dc:type rdf:resource="http://dublincore.org/usage/documents/principles/#element"/>
<dcterms:hasVersion rdf:resource="http://dublincore.org/usage/terms/history/#title-004"/>
</rdf:Property>
<rdf:Property rdf:about="http://purl.org/dc/elements/1.1/creator">
<rdfs:label xml:lang="en-US">Creator</rdfs:label>
<rdfs:comment xml:lang="en-US">An entity primarily responsible for making the content 
		of the resource.</rdfs:comment>
<dc:description xml:lang="en-US">Examples of a Creator include a person, an organisation,
		or a service.  Typically, the name of a Creator should 
		be used to indicate the entity.</dc:description>
<rdfs:isDefinedBy rdf:resource="http://purl.org/dc/elements/1.1/"/>
<dcterms:issued>1999-07-02</dcterms:issued>
<dcterms:modified>2002-10-04</dcterms:modified>
<dc:type rdf:resource="http://dublincore.org/usage/documents/principles/#element"/>
<dcterms:hasVersion rdf:resource="http://dublincore.org/usage/terms/history/#creator-004"/>
</rdf:Property>
<rdf:Property rdf:about="http://purl.org/dc/elements/1.1/subject">
<rdfs:label xml:lang="en-US">Subject and Keywords</rdfs:label>
<rdfs:comment xml:lang="en-US">The topic of the content of the resource.</rdfs:comment>
<dc:description xml:lang="en-US">Typically, a Subject will be expressed as keywords,
		key phrases or classification codes that describe a topic
		of the resource.  Recommended best practice is to select 
		a value from a controlled vocabulary or formal 
		classification scheme.</dc:description>
<rdfs:isDefinedBy rdf:resource="http://purl.org/dc/elements/1.1/"/>
<dcterms:issued>1999-07-02</dcterms:issued>
<dcterms:modified>2002-10-04</dcterms:modified>
<dc:type rdf:resource="http://dublincore.org/usage/documents/principles/#element"/>
<dcterms:hasVersion rdf:resource="http://dublincore.org/usage/terms/history/#subject-004"/>
</rdf:Property>
<rdf:Property rdf:about="http://purl.org/dc/elements/1.1/description">
<rdfs:label xml:lang="en-US">Description</rdfs:label>
<rdfs:comment xml:lang="en-US">An account of the content of the resource.</rdfs:comment>
<dc:description xml:lang="en-US">Description may include but is not limited to: an abstract,
		table of contents, reference to a graphical representation
		of content or a free-text account of the content.</dc:description>
<rdfs:isDefinedBy rdf:resource="http://purl.org/dc/elements/1.1/"/>
<dcterms:issued>1999-07-02</dcterms:issued>
<dcterms:modified>2002-10-04</dcterms:modified>
<dc:type rdf:resource="http://dublincore.org/usage/documents/principles/#element"/>
<dcterms:hasVersion rdf:resource="http://dublincore.org/usage/terms/history/#description-004"/>
</rdf:Property>
<rdf:Property rdf:about="http://purl.org/dc/elements/1.1/publisher">
<rdfs:label xml:lang="en-US">Publisher</rdfs:label>
<rdfs:comment xml:lang="en-US">An entity responsible for making the resource available</rdfs:comment>
<dc:description xml:lang="en-US">Examples of a Publisher include a person, an organisation,
		or a service.
		Typically, the name of a Publisher should be used to
		indicate the entity.</dc:description>
<rdfs:isDefinedBy rdf:resource="http://purl.org/dc/elements/1.1/"/>
<dcterms:issued>1999-07-02</dcterms:issued>
<dcterms:modified>2002-10-04</dcterms:modified>
<dc:type rdf:resource="http://dublincore.org/usage/documents/principles/#element"/>
<dcterms:hasVersion rdf:resource="http://dublincore.org/usage/terms/history/#publisher-004"/>
</rdf:Property>
<rdf:Property rdf:about="http://purl.org/dc/elements/1.1/contributor">
<rdfs:label xml:lang="en-US">Contributor</rdfs:label>
<rdfs:comment xml:lang="en-US">An entity responsible for making contributions to the
		content of the resource.</rdfs:comment>
<dc:description xml:lang="en-US">Examples of a Contributor include a person, an 
		organisation, or a service.  Typically, the name of a 
		Contributor should be used to indicate the entity.</dc:description>
<rdfs:isDefinedBy rdf:resource="http://purl.org/dc/elements/1.1/"/>
<dcterms:issued>1999-07-02</dcterms:issued>
<dcterms:modified>2002-10-04</dcterms:modified>
<dc:type rdf:resource="http://dublincore.org/usage/documents/principles/#element"/>
<dcterms:hasVersion rdf:resource="http://dublincore.org/usage/terms/history/#contributor-004"/>
</rdf:Property>
<rdf:Property rdf:about="http://purl.org/dc/elements/1.1/date">
<rdfs:label xml:lang="en-US">Date</rdfs:label>
<rdfs:comment xml:lang="en-US">A date associated with an event in the life cycle of the
		resource.</rdfs:comment>
<dc:description xml:lang="en-US">Typically, Date will be associated with the creation or
		availability of the resource.  Recommended best practice
		for encoding the date value is defined in a profile of
		ISO 8601 [W3CDTF] and follows the YYYY-MM-DD format.</dc:description>
<rdfs:isDefinedBy rdf:resource="http://purl.org/dc/elements/1.1/"/>
<dcterms:issued>1999-07-02</dcterms:issued>
<dcterms:modified>2002-10-04</dcterms:modified>
<dc:type rdf:resource="http://dublincore.org/usage/documents/principles/#element"/>
<dcterms:hasVersion rdf:resource="http://dublincore.org/usage/terms/history/#date-004"/>
</rdf:Property>
<rdf:Property rdf:about="http://purl.org/dc/elements/1.1/type">
<rdfs:label xml:lang="en-US">Resource Type</rdfs:label>
<rdfs:comment xml:lang="en-US">The nature or genre of the content of the resource.</rdfs:comment>
<dc:description xml:lang="en-US">Type includes terms describing general categories, functions,
		genres, or aggregation levels for content. Recommended best
		practice is to select a value from a controlled vocabulary
		(for example, the DCMI Type Vocabulary [DCMITYPE]). To 
		describe the physical or digital manifestation of the 
		resource, use the Format element.</dc:description>
<rdfs:isDefinedBy rdf:resource="http://purl.org/dc/elements/1.1/"/>
<dcterms:issued>1999-07-02</dcterms:issued>
<dcterms:modified>2002-10-04</dcterms:modified>
<dc:type rdf:resource="http://dublincore.org/usage/documents/principles/#element"/>
<dcterms:hasVersion rdf:resource="http://dublincore.org/usage/terms/history/#type-004"/>
</rdf:Property>
<rdf:Property rdf:about="http://purl.org/dc/elements/1.1/format">
<rdfs:label xml:lang="en-US">Format</rdfs:label>
<rdfs:comment xml:lang="en-US">The physical or digital manifestation of the resource.</rdfs:comment>
<dc:description xml:lang="en-US">Typically, Format may include the media-type or dimensions of
		the resource. Format may be used to determine the software,
		hardware or other equipment needed to display or operate the
		resource. Examples of dimensions include size and duration.
		Recommended best practice is to select a value from a
		controlled vocabulary (for example, the list of Internet Media
		Types [MIME] defining computer media formats).</dc:description>
<rdfs:isDefinedBy rdf:resource="http://purl.org/dc/elements/1.1/"/>
<dcterms:issued>1999-07-02</dcterms:issued>
<dcterms:modified>2002-10-04</dcterms:modified>
<dc:type rdf:resource="http://dublincore.org/usage/documents/principles/#element"/>
<dcterms:hasVersion rdf:resource="http://dublincore.org/usage/terms/history/#format-004"/>
</rdf:Property>
<rdf:Property rdf:about="http://purl.org/dc/elements/1.1/identifier">
<rdfs:label xml:lang="en-US">Resource Identifier</rdfs:label>
<rdfs:comment xml:lang="en-US">An unambiguous reference to the resource within a given context.</rdfs:comment>
<dc:description xml:lang="en-US">Recommended best practice is to identify the resource by means
		of a string or number conforming to a formal identification
		system.
		Example formal identification systems include the Uniform
		Resource Identifier (URI) (including the Uniform Resource
		Locator (URL)), the Digital Object Identifier (DOI) and the
		International Standard Book Number (ISBN).</dc:description>
<rdfs:isDefinedBy rdf:resource="http://purl.org/dc/elements/1.1/"/>
<dcterms:issued>1999-07-02</dcterms:issued>
<dcterms:modified>2002-10-04</dcterms:modified>
<dc:type rdf:resource="http://dublincore.org/usage/documents/principles/#element"/>
<dcterms:hasVersion rdf:resource="http://dublincore.org/usage/terms/history/#identifier-004"/>
</rdf:Property>
<rdf:Property rdf:about="http://purl.org/dc/elements/1.1/source">
<rdfs:label xml:lang="en-US">Source</rdfs:label>
<rdfs:comment xml:lang="en-US">A reference to a resource from which the present resource
		is derived.</rdfs:comment>
<dc:description xml:lang="en-US">The present resource may be derived from the Source resource
		in whole or in part.  Recommended best practice is to reference
		the resource by means of a string or number conforming to a
		formal identification system.</dc:description>
<rdfs:isDefinedBy rdf:resource="http://purl.org/dc/elements/1.1/"/>
<dcterms:issued>1999-07-02</dcterms:issued>
<dcterms:modified>2002-10-04</dcterms:modified>
<dc:type rdf:resource="http://dublincore.org/usage/documents/principles/#element"/>
<dcterms:hasVersion rdf:resource="http://dublincore.org/usage/terms/history/#source-004"/>
</rdf:Property>
<rdf:Property rdf:about="http://purl.org/dc/elements/1.1/language">
<rdfs:label xml:lang="en-US">Language</rdfs:label>
<rdfs:comment xml:lang="en-US">A language of the intellectual content of the resource.</rdfs:comment>
<dc:description xml:lang="en-US">Recommended best practice is to use RFC 3066 [RFC3066],
		which, in conjunction with ISO 639 [ISO639], defines two-
		and three-letter primary language tags with optional
		subtags.  Examples include "en" or "eng" for English,
		"akk" for Akkadian, and "en-GB" for English used in the
		United Kingdom.</dc:description>
<rdfs:isDefinedBy rdf:resource="http://purl.org/dc/elements/1.1/"/>
<dcterms:issued>1999-07-02</dcterms:issued>
<dcterms:modified>2002-10-04</dcterms:modified>
<dc:type rdf:resource="http://dublincore.org/usage/documents/principles/#element"/>
<dcterms:hasVersion rdf:resource="http://dublincore.org/usage/terms/history/#language-005"/>
</rdf:Property>
<rdf:Property rdf:about="http://purl.org/dc/elements/1.1/relation">
<rdfs:label xml:lang="en-US">Relation</rdfs:label>
<rdfs:comment xml:lang="en-US">A reference to a related resource.</rdfs:comment>
<dc:description xml:lang="en-US">Recommended best practice is to reference the resource by means
		of a string or number conforming to a formal identification
		system.</dc:description>
<rdfs:isDefinedBy rdf:resource="http://purl.org/dc/elements/1.1/"/>
<dcterms:issued>1999-07-02</dcterms:issued>
<dcterms:modified>2002-10-04</dcterms:modified>
<dc:type rdf:resource="http://dublincore.org/usage/documents/principles/#element"/>
<dcterms:hasVersion rdf:resource="http://dublincore.org/usage/terms/history/#relation-004"/>
</rdf:Property>
<rdf:Property rdf:about="http://purl.org/dc/elements/1.1/coverage">
<rdfs:label xml:lang="en-US">Coverage</rdfs:label>
<rdfs:comment xml:lang="en-US">The extent or scope of the content of the resource.</rdfs:comment>
<dc:description xml:lang="en-US">Coverage will typically include spatial location (a place name
		or geographic coordinates), temporal period (a period label,
		date, or date range) or jurisdiction (such as a named
		administrative entity).
		Recommended best practice is to select a value from a
		controlled vocabulary (for example, the Thesaurus of Geographic
		Names [TGN]) and that, where appropriate, named places or time
		periods be used in preference to numeric identifiers such as
		sets of coordinates or date ranges.</dc:description>
<rdfs:isDefinedBy rdf:resource="http://purl.org/dc/elements/1.1/"/>
<dcterms:issued>1999-07-02</dcterms:issued>
<dcterms:modified>2002-10-04</dcterms:modified>
<dc:type rdf:resource="http://dublincore.org/usage/documents/principles/#element"/>
<dcterms:hasVersion rdf:resource="http://dublincore.org/usage/terms/history/#coverage-004"/>
</rdf:Property>
<rdf:Property rdf:about="http://purl.org/dc/elements/1.1/rights">
<rdfs:label xml:lang="en-US">Rights Management</rdfs:label>
<rdfs:comment xml:lang="en-US">Information about rights held in and over the resource.</rdfs:comment>
<dc:description xml:lang="en-US">Typically, a Rights element will contain a rights
		management statement for the resource, or reference
		a service providing such information. Rights information
		often encompasses Intellectual Property Rights (IPR),
		Copyright, and various Property Rights.
		If the Rights element is absent, no assumptions can be made
		about the status of these and other rights with respect to
		the resource.</dc:description>
<rdfs:isDefinedBy rdf:resource="http://purl.org/dc/elements/1.1/"/>
<dcterms:issued>1999-07-02</dcterms:issued>
<dcterms:modified>2002-10-04</dcterms:modified>
<dc:type rdf:resource="http://dublincore.org/usage/documents/principles/#element"/>
<dcterms:hasVersion rdf:resource="http://dublincore.org/usage/terms/history/#rights-004"/>
</rdf:Property>
</rdf:RDF>
