5. Data Schemas

A data schema is a description of a set of allowed data types. P3P includes a way to describe data schemas so that services can communicate to user agents about the types of data they collect. A data schema is a hierarchical set of data types, which are specific classes of data a service might collect.

P3P 1.1. provides a new format for expressing P3P data schemas in a simpler and more standardized way than P3P 1.0. The new format uses the XML Schema Structures and Datatypes which can be validated against an XML schema. Backward compatibility is addressed as follows:

New custom data schemas SHOULD be written using only the new format.
Policy instances conforming to custom schemas written in the new format may be written using only the new format data elements, but MUST be published with the backward compatibility transform of the data elements in the policy so that the data elements are readable by P3P1.0 user agents. The schema itself may be published only in the new format however. This means that P3P1.0 user agents will be able to parse data elements but they will not be able to validate them. The backward compatibility transform translates the extension datatype elements into P3P1.0 compatible elements.

Datatype sub-elements are organized into a class-like hierarchy of increasing specificity. For an element b to be definied as an allowed child of element a signifies that if an entity is stated to collect data of type a, then it may also collect data of type b. The inverse relation however does not hold. Transitivity also holds for this relation. That is, if a statement states that entity x may collect data of type a and b is an allowed structure of a and c is an allowed structure of b, then it can be assumed that x may collect data of type c. For example, the data element representing "the user's name" may include the data elements representing "the user's given name", "the user's family name", and so on. The hierarchy is mirrored by the hierarchy of XML elements used to express them.

For example,

  <user>
    <name>
      <given/>
    </name>
  </user>,
  <user>
    <name>
      <family/>
    </name>
  </user>

etc…

P3P has defined an XML schema called the P3P base data schema that includes a large number of data elements commonly used by services. Note that the data element names specified in the base data schema or in extension data schemas may be used for purposes other than P3P policies. For example, Web sites may use these names to label HTML form fields. By referring to data the same way in P3P policies and forms, automated form-filling tools can be better integrated with P3P user agents.

5.1. How to express data types in P3P Policies

5.1.1 Basics

The following is an example instance of a data schema compliant datatype element, full details of the data schema hierarchy are given in section 5.4.

  <DATA-GROUP>
    <EXTENSION>
      <datatype>
        <dynamic>
          <clickstream>
            <CATEGORY>preference</CATEGORY>
          </clickstream>
        </dynamic>
      </datatype>
    </EXTENSION>
  </DATA-GROUP>

This example shows the following aspects of how to use a data schema in P3P 1.1

Root is always an element name datatype.
Under this are nested elements describing the types of data that the P3P Statement is about. The hierarchy of these elements is describted in detail in section 5.4
Greater levels of detail in the specification of a data type are expressed by using allowed children of a particular class, according the the scheme expressed in taken to mean subclassing so for instance in the above example, clickstream data is a subclass of dynamic data.
Natural language descriptors of the meaning of these elements are found in the Data Schema and therefore should not be included in policy instances. The human readable descriptor corresponds to an XSD comment beneath the element it refers to, of format:
```
  <annotation>
    <documentation>
      This element can describe the capture of
      HTTP Protocol Information such as header values
    </documentation>
    <appinfo>
      HTTP Protocol Information
    </appinfo>
  </annotation>
  
```
User agents should use these descriptors when rendering data types in human readable format (for example in a human readable translation of a P3P policy).
Most data elements have categories assigned to them when they are defined in a data schema. See 5.1.2 Categories for more information on categories.

5.1.2 Categories in P3P Data Schemas

Categories may be assigned at the lowest level of a data type definition. The purpose of a category is to delimit a certain data type - for instance clickstream data may be delimited as navigation, computer or demographic type clickstream data.

In this capacity as delimiters, the category can only be assigned as a leaf child (with only other category siblings) of the hierarchy.

For example the following is correct syntax.

  <datatype>
    <dynamic>
      <cookies>
        <CATEGORY>preference</CATEGORY>
      </cookies>
    </dynamic>
  </datatype>

Whereas the following is not:

  <datatype>
    <dynamic>
      <cookies/>
      <CATEGORY>preference</CATEGORY>
    </dynamic>
  </datatype>

Categories are simply appended to the lowest level of the hierarchy specified. Most of the elements in the base data schema are so called "fixed"data elements: they belong to one or at most two category classes. By assigning a category invariably to elements or structures in the base data schema, services and users are able to refer to entire groups of elements simply by referencing the corresponding category. For example, using [APPEL], the privacy preferences exchange language, users can write rules that warn them when they visit a site that collects any data element in a certain category.

If an element or structure belongs to multiple categories, multiple elements referencing the appropriate categories can be used. For example, the following piece of XML can be used to declare that the data elements in user.name have both category "physical" and "demographic":

  <datatype>
    <dynamic>
      <cookies>
        <CATEGORY>preference</CATEGORY>
        <CATEGORY>demographic</CATEGORY>
      </cookies>
    </dynamic>
  </datatype>

Please note that the category classes of fixed data elements/structures can notbe overridden, for example by writing APPEL rules or policies that assign a different category to a known fixed base data element. User agents MUST ignore such categories and instead use the original category (or set of categories) listed in the schema definition. User agents MAY preferably alert the user that a fixed data element is used together with a non-standard category class.

5.7.2 Variable-Category Data Elements/Structures

Not all data elements in the base data schema belong to a pre-determined category. Some can contain information from a range of categories, depending on a particular situation. Such elements/structures are called variable-category data elements/structures (or "variable data element" for short). Although most variable data elements in the P3P base data schema are combined in the dynamicelement set, they can appear in any data set, even mixed with fixed-category data elements.

Variable category elements are distinguished by the fact that the schema defining them (including the base data schema) does list an explicit category attribute, otherwise the element/structure becomes fixed. For example when specifying the "Year" Data Element, which can take various categories depending on the situation (e.g. when used for a credit card expiration date vs. for a birth date), the following schema definition can be used:

    <element name="year"/> 
    <!-- Variable Data Structure-->

5.7.3 Referencing External Schemas

External schemas may reference elements in other schemas simply by referring to another namespace. For example

  <schema targetNamespace='http://www.example.com/Report'
  xmlns:p3pBDS='http://www.w3.org/P3P/BDS.xml'>
    <xs:element name="creditCard">
      <xs:element ref="p3pBDS:date"/>
    </xs:element>
  </schema>

But note that in contrast to the P3P 1.0 data schema format, it is not possible to alter the category assignations of reused elements. If this is required, they must be redefined. Schema extensions may still reference elements in other schemas (e.g. reuse of date element), but they may not assign a category (you cannot change the properties of a referenced element within XSD)]

Note that while user preferences can list such variable data elements without any additional category information (effectively expressing preferences over any usage of this element), services MUST always explicitly specify the categories that apply to the usage of a variable data element in their particular policy. This information has to appear as a category element in the corresponding DATA element listed in the policy, for example as in:

  <datatype>
    <dynamic>
      <cookies>
        <CATEGORY>preference</CATEGORY>
      </cookies>
    </dynamic>
  </datatype>

where a service declares that cookies are used to recognize the user at this site (i.e. category Unique Identifiers).

If a service wants to declare that a data element is in multiple categories, it simply declares the corresponding categories as in:

  <datatype>
    <dynamic>
      <cookies>
        <CATEGORY>preference</CATEGORY>
        <CATEGORY>uniqueid</CATEGORY>
      </cookies>
    </dynamic>
  </datatype>

With the above declaration a service announces that it uses cookies both to recognize the user at this site and for storing user preference data. Note that for the purpose of P3P there is no difference whether this information is stored in two separate cookies or in a single one.

Finally, note that categories can be inherited as well: Categories inherit downward when a field is structured, but only into fields which have no predefined category. Therefore, we suggest to schema authors that they do their best to insure that all applicable categories are applied to new data elements they create.

5.1.3 Natural Language description of data elements

Natural language descriptions of the meaning of data elements may be found within <annotation> children of the element definition in the schema. These may be of 2 kinds:

<description>: a long description for documentation purposes

<appinfo>: a short description for display in data capture summaries.

These descriptions are intended to be used by user-agents in creating translations to human readable policies. They should not however be included in machine readable policies.

5.2 Defining new Schemas

Services may declare new data elements by creating and publishing their own data schemas expressed using XSD according to certain rules over and above the rules of correct XSD syntax . This section describes the rules for creating these schemas. These new data schemas are then referred to simply using the xmlns attribute for the elements below the datatype element. [NOTE - do we need to declare the BDS namespace every time we use it]

5.2.1 Allowed Structure of XSD Schemas

New schemas can be defined using the XML Schema Definition language [ref], they must follow the following rules:

As with the P3P Base Data Schema, datatype sub-elements must be organized into a class-like hierarchy of increasing specificity. For an element b to be definied as an allowed child of element a signifies that if an entity is stated to collect data of type a, then it may also collect data of type b. The inverse relation however does not hold. Transitivity also holds for this relation. That is, if a statement states that entity x may collect data of type a and b is an allowed structure of a and c is an allowed structure of b, then it can be assumed that x may collect data of type c. For example <classicalmusicpreference> would be defined as an allowed subelement of <musicalpreference>. Subclassing is inherited so <baroquemusicpreference> is understood to be a subclass of <musicalpreference> because it is a subelement of <classicalmusicpreference> which is a subelement of <musicalpreference>

This could be expressed in the following XSD:

  <element minoccurs="0" maxoccurs="1" name="musical-preference">
    <element minoccurs="0" maxoccurs="1" ref="classicalmusic-preference"/>
      <annotation>
        <documentation>
          Musical Preferences
        </documentation>
      </annotation>
      <element ref="CATEGORY" minoccurs="0" maxoccurs="*" type="allCategories"/>
    </element>

    <element minoccurs="0" maxoccurs="1" name="classicalmusic-preference">
      <annotation>
        <documentation>
          Classical Musical Preferences
        </documentation>
      </annotation>
      <element minoccurs="0" maxoccurs="1" ref="baroquemusic-preference"/>
    </element>

    <element minoccurs="0" maxoccurs="1"
    name="baroquemusic-preference">
      <annotation>
        <documentation>
          Classical Musical Preferences
        </documentation>
      </annotation>
  </element>

5.2.2 Defining categories in custom schemas.

Categories may be assigned at any level of the XML hierarchy
At least one category must be defined for each element defined.
Possible categories must be declared as an xsd datatype
To declare that any category may be used, just use the following:
<element name="CATEGORY" minoccurs="0" maxoccurs="*" type="allCategories" />
Categories must follow a bubble-up rule in that any categories assigned to a lower level element must also be assigned to any of its ancestors. This mirrors real-world semantics where possible categories assigned to classes are upwards inherited.
Categories must be defined as restrictions on a global data type for the schema which is defined as a root level element. For example in the BDS, the following element is defined:

  <simpleType name="allCategories">

    <restriction base="xs:string">

      <enumeration value="uniqueid">
      </enumeration>
      <enumeration value="demographic">
      </enumeration>
      <enumeration value="physical">
      </enumeration>
      <enumeration value="online">
      </enumeration>
      <enumeration value="computer">
      </enumeration>
      <enumeration value="navigation">
      </enumeration>
      <enumeration value="interactive">
      </enumeration>

    </restriction>

  </simpleType>

Definition of allowed categories for a particular datatype are then taken as restrictions of this basic data type - for example:

  <element name="CATEGORY" minoccurs="0" maxoccurs="*">
    <simpleType>
      <restriction base="allCategories">
        <pattern value="computer" />
      </restriction>
    </simpleType>
  </element>

Note that this must be placed as a leaf node in the hierarchy (i.e. it should have no children) and it must only have category siblings.

5.2.3 Natural Language Annotations in Data Schemas

P3P data typing XSD's alllow two annotation fields for natural language description. Below each element description, schema creators MAY place an xsd:annotation element with the following child elements:

<description>: a long description for documentation purposes

<appinfo>: a short description for display in policy summaries.

Services publishing a data schema MAY wish to translate these fields into multiple languages. The annotation element's contents MAY be translated, but the element name MUST NOT be translated - this field needs to stay constant across translations of a data schema.

If a service is going to provide a data schema in multiple natural languages, then it SHOULD examine the Accept-Language HTTP request-header on requests for that data schema to pick the best available alternative.

5.3 Persistence of data schemas

An essential requirement on data schemas is the persistence of data schemas: data schemas that can be fetched at a certain URI can only be changed by extending the data schema in a backward-compatible way (that is to say, changing the data schema does not change the meaning of any policy using that schema). This way, the URI of a policy acts in a sense like a unique identifier for the data elements and structures contained therein: any data schema that is not backward-compatible must therefore use a new different URI.

Note that a useful application of the persistence of data schema is given for example in the case of multi-lingual sites: multiple language versions (translations) of the same data schema can be offered by the server, using the HTTP "Content-Language" response header field to properly indicate that a particular language has been used for the data schema.

5.4 Structure of Base Data Schema

The XML schema is not designed to be human readable, but in writing policies, it is convenient to have a picture of the hierarchy of categories available. The following gives a description of the different elements available. This hierarchy and the XML schema specify for each element what its possible parents and children may be. This is clarified in the diagrams in Section 5.5. All P3P-compliant user agent implementations MUST be aware of the Base Data Schema. Each table below specifies the a level of the Base Data Schema. A diagrammatic representation of the tree can be found at http://p3p.jrc.it/P3PTaxonomy/dataschematransformer.xml. The following also specifies the categories associated and the display names shown to users. More than one category may be associated with a fixed data element. However, each base data element is assigned to only one category whenever possible. Data schema designers are recommended to do the same.

The following four classes are the root classes

5.4.1 Level 1.

5.4.1.1 Level 1 Elements 1. - User

The user data set includes general information about the user. The following table gives its allowed subclasses.

user	Allowed Categories	Allowed Descendents defined by	Appinfo
name	Physical Contact Information, Demographic and Socioeconomic Data	personname [NB in the new scheme, only one type of name is allowed]	User's Name
bdate	Demographic and Socioeconomic Data	date	User's Birth Date
login	Unique Identifiers	login	User's Login Information
cert	Unique Identifiers	certificate	User's Identity Certificate
gender	Demographic and Socioeconomic Data	none	User's Gender (Male or Female)
employer	Demographic and Socioeconomic Data	none	User's Employer
department	Demographic and Socioeconomic Data	none	Department or Division of Organization where User is Employed
jobtitle	Demographic and Socioeconomic Data	none	User's Job Title
home-info	Physical Contact Information, Online Contact Information, Demographic and Socioeconomic Data	contact	User's Home Contact Information
business-info	Physical Contact Information, Online Contact Information, Demographic and Socioeconomic Data	contact	User's Business Contact Information

Note, that each of these possible subelements this data set includes elements that have further possible subclasses coming under level 2.

5.4.1.2 Level 1 Elements 2. - Thirdparty

The thirdparty data set allows users and businesses to provide values for a related third party. This can be useful whenever third party information needs to be exchanged, for example when ordering a present online that should be sent to another person, or when providing information about one's spouse or business partner. Such information could be stored in a user repository alongside the user data set. User agents may offer to store multiple such thirdparty data sets and allow users to select the appropriate values from a list when necessary.

The allowed subclasses of thirdparty data set is identical to those of the user data set. See section Level 1 elements User for details.

5.4.1.3 Level 1 Elements 3. - Business

The business data set features a subset of user data relevant for describing legal entities. In P3P1.0, this data set is primarily used for declaring the policy entity, although it should also be applicable to business-to-business interactions. The following table gives its allowed subclasses.

business	Allowed Categories	Allowed Descendents defined by	Appinfo
name	Demographic and Socioeconomic Data	none	Organization Name
department	Demographic and Socioeconomic Data	none	Department or Division of Organization
cert	Unique Identifiers	certificate	Organization Identity Certificate
contact-info	Physical Contact Information, Online Contact Information, Demographic and Socioeconomic Data	contact	Contact Information for the Organization

5.4.1.4 Level 1 Elements 4. - Dynamic

In some cases, there is a need to specify data elements that do not have fixed values that a user might type in or store in a repository. In the P3P base data schema, all such elements are grouped under the dynamic data set. Sites may refer to the types of data they collect using the dynamic data set only, rather than enumerating all of the specific data elements.

dynamic	Allowed Categories	Appinfo
clickstream	Navigation and Click-stream Data, Computer Information	Click-stream Information
http	Navigation and Click-stream Data, Computer Information	HTTP Protocol Information
clientevents	Navigation and Click-stream Data	User's Interaction with a Resource
cookies	( variable-category)	Use of HTTP Cookies
miscdata	( variable-category)	Miscellaneous Non-base Data Schema Information
searchtext	Interactive Data	Search Terms
interactionrecord	Interactive Data	Server Stores the Transaction History

These elements are often implicit in navigation or Web interactions. They should be used with categories to describe the type of information collected through these methods. A brief description of each element follows.

clickstream

The clickstream element is expected to apply to practically all Web sites. It represents the combination of information typically found in Web server access logs: the IP address or hostname of the user's computer, the URI of the resource requested, the time the request was made, the HTTP method used in the request, the size of the response, and the HTTP status code in the response. Web sites that collect standard server access logs as well as sites which do URI path analysis can use this data element to describe how that data will be used. Web sites that collect only some of the data elements listed for the clickstream element MAY choose to list those specific elements rather than the entire dynamic.clickstream element. This allows sites with more limited data-collection practices to accurately present those practices to their visitors.

http

The http element contains additional information contained in the HTTP protocol. See the definition of the httpinfo structure for descriptions of specific elements. Sites MAY use the dynamic.http field as a shorthand to cover all the elements in the httpinfo structure if they wish, or they MAY reference the specific elements in the httpinfo structure.

clientevents

The clientevents element represents data about how the user interacts with their Web browser while interacting with a resource. For example, an application may wish to collect information about whether the user moved their mouse over a certain image on a page, or whether the user ever brought up the help window in a Java applet. This kind of information is represented by the dynamic.clientevents data element. Much of this interaction record is represented by the events and data defined by the Document Object Model (DOM) Level 2 Events [DOM2-Events]. The clientevents data element also covers any other data regarding the user's interaction with their browser while the browser is displaying a resource. The exception is events which are covered by other elements in the base data schema. For example, requesting a page by clicking on a link is part of the user's interaction with their browser while viewing a page, but merely collecting the URL the user has clicked on does not require declaring this data element; clickstream covers that event. However, the DOM event DOMFocusIn (representing the user moving their mouse over an object on a page) is not covered by any other existing element, so if a site is collecting the occurrence of this event, then it needs to state that it collects the dynamic.clientevents element. Items covered by this data element are typically collected by client-side scripting languages, such as JavaScript, or by client-side applets, such as ActiveX or Java applets. Note that while the previous discussion has been in terms of a user viewing a resource, this data element also applies to Web applications which do not display resources visually - for example, audio-based Web browsers.

cookies

The cookies element should be used whenever HTTP cookies are set or retrieved by a site. Please note that cookies is a variable data element and requires the explicit declaration of usage categories in a policy.

miscdata

The miscdata element references information collected by the service that the service does not reference using a specific data element. Categories have to be used to better describe these data: sites MUST reference a separate miscdata element in their policies for each category of miscellaneous data they collect.

searchtext

The searchtext element references a specific type of solicitation used for searching and indexing sites. For example, if the only fields on a search engine page are search fields, the site only needs to disclose that data element.

interactionrecord

The interactionrecord element should be used if the server is keeping track of the interaction it has with the user (i.e. information other than clickstream data, for example account transactions, etc).

5.4.2 Lower Level Reuseable Elements

The following summarises the elements and their allowed children which are used at various levels of the taxonomy for providing more detailed description of data elements. Note the full structure of allowed elements is summarized graphically in 5.6.

5.4.2.1 Date

The dateelement and its children refer to dates. Since date information can be used in different ways, depending on the context, all date information is tagged as being of variable category (see Section 5.7.2). For example, schema definitions can explicitly set the corresponding category in the element referencing this data structure, where soliciting the birthday of a user might be "Demographic and Socioeconomic Data", while the expiration date of a credit card might belong to the Purchase Information category.

date	Category	Allowed Descendents defined by	Appinfo
ymd.year	(variable-category)	unstructured	Year
ymd.month	(variable-category)	unstructured	Month
ymd.day	(variable-category)	unstructured	Day
hms.hour	(variable-category)	unstructured	Hour
hms.minute	(variable-category)	unstructured	Minute
hms.second	(variable-category)	unstructured	Second
fractionsecond	(variable-category)	unstructured	Fraction of Second
timezone	(variable-category)	unstructured	Time Zone

The "time zone" information is for example described in the time standard [ISO8601]. Note that "date.ymd" and "date.hms" can be used to fast reference the year/month/day and hour/minute/second blocks respectively.

5.4.2.2 Names

The element and its children specifies information about the naming of a person or organization or person. An organization name will generally not extend to the subelements listed below.

Name	Category	Allowed Descendents defined by	Appinfo
prefix	Demographic and Socioeconomic Data	unstructured	Name Prefix
given	Physical Contact Information	unstructured	Given Name (First Name)
family	Physical Contact Information	unstructured	Family Name (Last Name)
middle	Physical Contact Information	unstructured	Middle Name
suffix	Demographic and Socioeconomic Data	unstructured	Name Suffix
nickname	Demographic and Socioeconomic Data	unstructured	Nickname

5.4.2.3 Logins

The login element and its children refer to information (IDs and passwords) for computer systems and Web sites which require authentication. Note that this data element should not be used for computer systems or Web sites which use digital certificates for authentication: in those cases, the certificate structure should be used.

login	Category	Allowed Descendents defined by	Appinfo
id	Unique Identifiers	unstructured	Login ID
password	Unique Identifiers	unstructured	Login Password

The "id" field represents the ID portion of the login information for a computer system. Often, user IDs are made public, while passwords are kept secret. IDs do not include any type of biometric authentication mechanisms.

The "password" field represents the password portion of the login information for a computer system. This is a secret data value, usually a character string, that is used in authenticating a user. Passwords are typically kept secret, and are generally considered to be sensitive information

5.4.2.4 Certificates

The certificate element and its children refer to identity certificates (like, for example, X.509).

certificate	Category	Allowed Descendents defined by	Appinfo
key	Unique Identifiers	unstructured	Certificate Key
format	Unique Identifiers	unstructured	Certificate Format

The "format" field is used to represent the information of an IANA registered public key or authentication certificate format, while the "key" field is used to represent the corresponding certificate key.

5.4.2.6 Contact Information

The contact element and its children refer to contact information. Services can specify precisely which set of data they need, postal, telecommunication, or online address information.

contact	Category	Allowed Descendents defined by	Appinfo
postal	Physical Contact Information, Demographic and Socioeconomic Data	postal	Postal Address Information
telecom	Physical Contact Information	telecom	Telecommunications Information
online	Online Contact Information	online	Online Address Information

5.4.2.7 Telephone Numbers

The telephonenumelement and its children refer to the characteristics of a telephone number.

telephonenum	Category	Allowed Descendents defined by	Appinfo
intcode	Physical Contact Information	unstructured	International Telephone Code
loccode	Physical Contact Information	unstructured	Local Telephone Area Code
number	Physical Contact Information	unstructured	Telephone Number
ext	Physical Contact Information	unstructured	Telephone Extension
comment	Physical Contact Information	unstructured	Telephone Optional Comments

5.4.2.8 Postal Information

The postal element and its children refer to a postal mailing address.

postal	Category	Allowed Descendents defined by	Appinfo
name	Physical Contact Information, Demographic and Socioeconomic Data	personname	Name
street	Physical Contact Information	unstructured	Street Address
city	Demographic and Socioeconomic Data	unstructured	City
stateprov	Demographic and Socioeconomic Data	unstructured	State or Province
postalcode	Demographic and Socioeconomic Data	unstructured	Postal Code
country	Demographic and Socioeconomic Data	unstructured	Country Name
organization	Demographic and Socioeconomic Data	unstructured	Organization Name

The "country" field represents the information of the name of the country (for example, one among the countries listed in [ISO3166]).

5.4.2.9 Telecommunication Information

The telecomstructure specifies telecommunication information about a person.

telecom	Category	Allowed Descendents defined by	Appinfo
telephone	Physical Contact Information	telephonenum	Telephone Number
fax	Physical Contact Information	telephonenum	Fax Number
mobile	Physical Contact Information	telephonenum	Mobile Telephone Number
pager	Physical Contact Information	telephonenum	Pager Number

5.4.2.10 Online Information

The online element and its children refer to online information about a person or legal entity.

online	Category	Allowed Descendents defined by	Appinfo
email	Online Contact Information	unstructured	Email Address
uri	Online Contact Information	unstructured	Home Page Address

Elements for Access Logs

Two structures used for representing forms of Internet addresses are provided. The uri element and its children refer to Universal Resource Identifiers (URI), which are defined in [URI]. The ipaddr element and its children refer to IP addresses and Domain Name System (DNS) hostnames.

5.4.2.11 URI

uri	Category	Structure	Short display name
authority	(variable-category)	unstructured	URI Authority
stem	(variable-category)	unstructured	URI Stem
querystring	(variable-category)	unstructured	Query-string Portion of URI

The authority of a URI is defined as the authority component in [URI]. The stem of a URI is defined as the information contained in the portion of the URI after the authority and up to (and including) the first '?' character in the URI, and the querystring is the information contained in the portion of the URI after the first '?' character. For URIs which do not contain a '?' character, the stem is the entire URI, and the querystring is empty.

Since URI information can be used in different ways, depending on the context, all the fields in the uri structure are tagged as being of variable category. Schema definitions MUST explicitly set the corresponding category in the element referencing this data structure.

5.4.2.12 ipaddr

The ipaddr element and its children refer to the hostname and IP address of a system.

ipaddr	Category	Allowed Descendents defined by	Appinfo
hostname	Computer Information	unstructured	Complete Host and Domain Name
partialhostname	Demographic	unstructured	Partial Hostname
fullip	Computer Information	unstructured	Full IP Address
partialip	Demographic	unstructured	Partial IP Address

The hostname element is used to represent collection of either the simple hostname of a system, or the full hostname including domain name. The partialhostname element represents the information of a fully-qualified hostname which has had at least the host portion removed from the hostname. In other words, everything up to the first '.' in the fully-qualified hostname MUST be removed for an address to quality as a "partial hostname".

The fullip element represents the information of a full IP version 4 or IP version 6 address. The partialip element represents an IP version 4 address (only - not a version 6 address) which has had at least the last 7 bits of information removed. This removal MUST be done by replacing those bits with a fixed pattern for all visitors (for example, all 0's or all 1's).

Certain Web sites are known to make use not of the visitor's entire IP address or hostname, but rather make use of a reduced form of that information. By collecting only a subset of the address information, the site visitor is given some measure of anonymity. It is certainly not the intent of this specification to claim that these "stripped" IP addresses or hostnames are impossible to associate with an individual user, but rather that it is significantly more difficult to do so. Sites which perform this data reduction MAY wish to declare this practice in order to more-accurately reflect their practices.

5.4.2.13 Log Info

The loginfo element and its children refer to information typically stored in Web-server access logs.

loginfo	Category	Allowed Descendents defined by	Appinfo
uri	Navigation and click-stream data	uri	URI of Requested Resource
timestamp	Navigation and click-stream data	date	Request Timestamp
clientip	Computer Information, Demographic and Socioeconomic Data	ipaddr	Client's IP Address or Hostname
other.httpmethod	Navigation and click-stream data	unstructured	HTTP Request Method
other.bytes	Navigation and click-stream data	unstructured	Data Bytes in Response
other.statuscode	Navigation and click-stream data	unstructured	Response Status Code

The resource in the HTTP request is captured by the uri field. The time at which the server processes the request is represented by the timestamp field. Server implementations are free to define this field as the time the request was received, the time that the server began sending the response, the time that sending the response was complete, or some other convenient representation of the time the request was processed. The IP address of the client system making the request is given by the clientip field.

The other data fields represent other information commonly stored in Web server access logs. other.httpmethod is the HTTP method (such as GET, POST, etc) in the client's request. other.bytes indicates the number of bytes in the response-body sent by the server. other.statuscode is the HTTP status code on the request, such as 200, 302, or 404 (see section 6.1.1 of [HTTP1.1] for details).

5.4.2.13 Log Info Other HTTP Protocol Information

The httpinfo element and its children refer to information carried by the HTTP protocol which is not covered by the loginfo structure.

httpinfo	Category	Allowed Descendents defined by	Appinfo
referer	Navigation and click-stream data	uri	Last URI Requested by the User
useragent	Computer Information	unstructured	User Agent Information

The useragent field represents the information in the HTTP User-Agent header (which gives information about the type and version of the user's Web browser), and/or the HTTP accept* headers.

The referer field represents the information in the HTTP Referer header, which gives information about the previous page visited by the user. Note that this field is misspelled in exactly the same way as the corresponding HTTP header.

The full structure of the allowed hierarchy expressed by the data schema is summarized in the following four tables:

5.5 P3P Base Data Schema Visual Representation

The following gives a human readable view of the XML schema and shows which elements are permitted in policies.

1. Dynamic Data

  dynamic
    clickstream

      uri
        authority
        stem
        querystring
        
      timestamp
        ymd.year
        ymd.month
        ymd.day
        hms.hour
        hms.minute
        hms.second
        fractionsecond
        timezone

      clientip
        hostname
        partialhostname
        fullip
        partialip

      other.httpmethod
      other.bytes
      other.statuscode
    http
      referer
        authority
        stem
        querystring
              
    useragent
        clientevents
        cookies
        searchtext
        interactionrecord
        miscdata

User Data

  user
    name
      prefix
      given
      middle
      family
      suffix
      nickname
    bdate
      ymd.year
      ymd.month
      ymd.day
      hms.hour
      hms.minute
      hms.second
      fractionsecond
      timezone
    login
      id
      password
    cert
      key
      format
    gender
    jobtitle

    home-info
      postal
        name
          prefix
          given
          middle
          family
          suffix
          nickname
        street
        city
        stateprov
        postalcode
        organization
        country
        
      telecom
        telephone
          intcode
          loccode
          number
          ext
          comment
        fax
          intcode
          loccode
          number
          ext
          comment
        mobile
          intcode
          loccode
          number
          ext
          comment
        pager
          intcode
          loccode
          number
          ext
          comment
      online
        email
        uri

    business-info
      postal
        name
          prefix
          given
          middle
          family
          suffix
          nickname
        street
        city
        stateprov
        postalcode
        organization
        country
      telecom
        telephone
          intcode
          loccode
          number
          ext
          comment
        fax
          intcode
          loccode
          number
          ext
          comment
        mobile
          intcode
          loccode
          number
          ext
          comment
        pager
          intcode
          loccode
          number
          ext
          comment
      online
        email
        uri
      employer
      department

Third Party Data

  thirdparty
    name
      prefix
      given
      middle
      family
      suffix
      nickname
    bdate
      ymd.year
      ymd.month
      ymd.day
      hms.hour
      hms.minute
      hms.second
      fractionsecond
      timezone
    login
      id
      password
    cert
      key
      format
    gender
    jobtitle

    home-info
      postal
        name
          prefix
          given
          middle
          family
          suffix
          nickname
        street
        city
        stateprov
        postalcode
        organization
        country
        
      telecom
        telephone
          intcode
          loccode
          number
          ext
          comment
        fax
          intcode
          loccode
          number
          ext
          comment
        mobile
          intcode
          loccode
          number
          ext
          comment
        pager
          intcode
          loccode
          number
          ext
          comment
      online
        email
        uri

    business-info
      postal
        name
          prefix
          given
          middle
          family
          suffix
          nickname
        street
        city
        stateprov
        postalcode
        organization
        country
      telecom
        telephone
          intcode
          loccode
          number
          ext
          comment
        fax
          intcode
          loccode
          number
          ext
          comment
        mobile
          intcode
          loccode
          number
          ext
          comment
        pager
          intcode
          loccode
          number
          ext
          comment
      online
        email
        uri
      employer
      department

Business Data

business name department cert key format contact-info postal name prefix given middle family suffix nickname street city stateprov postalcode organization country telecom telephone intcode loccode number ext comment fax intcode loccode number ext comment mobile intcode loccode number ext comment pager intcode loccode number ext comment online email uri cert key format

5.6 Using Data Elements

P3P offers Web sites a lot of flexibility in how they describe the types of data they collect.

Sites may describe data generally using the <dynamic><miscdata/></dynamic> element and the appropriate categories.
Sites may describe data specifically using the data elements defined in the base data schema.
Sites may describe data specifically using data elements defined in new data schemas.

Any of these three methods may be combined within a single policy.

By using the < dynamic><miscdata/></dynamic> element, sites can specify the types of data they collect without having to enumerate every individual data element. This may be convenient for sites that collect a lot of data or sites belonging to large organizations that want to offer a single P3P policy covering the entire organization. However, the disadvantage of this approach is that user agents will have to assume that the site might collect any data element belonging to the categories referenced by the site. So, for example, if a site's policy states that it collects <dynamic><miscdata/></dynamic> of the physical contact information category, but the only physical contact information it collects is business address, user agents will nonetheless assume that the site might also collect telephone numbers. If the site wishes to be clear that it does not collect telephone numbers or any other physical contact information other than business address, than it should disclose that it collects <user><business-info><contact><postal/></contact></business-info></user>. Furthermore, as user agents are developed with automatic form-filling capabilities, it is likely that sites that enumerate the data they collect will be able to better integrate with these tools.

By defining new data schemas, sites can precisely specify the data they collect beyond the base data set. However, if user agents are unfamiliar with the elements defined in these schemas, they will be able to provide only minimal information to the user about these new elements. The information they provide will be based on the category and display names specified for each element.

Regardless of whether a site wishes to make general or specific data disclosures, there are additional advantages to disclosing specific elements from the <dynamic/>data set. For example, by disclosing <dynamic><cookies/></dynamic> a site can indicate that it uses cookies and explain the purpose of this use. User agent implementations that offer users cookie control interfaces based on this information are encouraged. Likewise, user agents that by default do not send the HTTP_REFERER header, might look for the <dynamic><http><referrer/></http></dynamic> element in P3P policies and send the header if it will be used for a purpose the user finds acceptable.

5.7 Semantics of P3P Data Schemas

XML does not define a formal semantics except when used within RDF. The use of XSD to define classes of data types however necessarily implies a correspondence between XML elements and real-world classes of data, which is therefore a form of semantics. We have chosen not to use a language with formal semantics because of the sparse support for such languages as RDF and OWL. [This section could do with some elaboration]. Some attempt has been made to translate the BDS into RDF and this issue will be examined by the P3P 2.0 specification WG.

5.8 Transforming between P3P 1.0 schemas and policies and P3P 1.1 schemas and policies.

We provide a set of XSLT schemas which can automatically make the following transformations:

P3P 1.0 Schema  P3P 1.1 Schema - XSLT at http:// www.w3.org..... etc..

P3P 1.0 Policy  P3P 1.1. Policy - XSLT at http://www.w3.org etc…

P3P 1.1 Policy  P3P 1.0 Policy - XSLT at http://www.w3.org etc…

Appendix 1. P3P XSD Base Data Schema

<?xml version="1.0" encoding="UTF-8"?>
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
 <xsd:element name="data-group">
  <xsd:complexType>
   <xsd:sequence>
    <xsd:element ref="datatype" minOccurs="0" maxOccurs="unbounded" />
   </xsd:sequence>
  </xsd:complexType>
 </xsd:element>
 <xsd:simpleType name="allCategories">
  <xsd:restriction base="xsd:string">
   <xsd:enumeration value="uniqueid">
   </xsd:enumeration>
   <xsd:enumeration value="demographic">
   </xsd:enumeration>
   <xsd:enumeration value="physical">
   </xsd:enumeration>
   <xsd:enumeration value="online">
   </xsd:enumeration>
   <xsd:enumeration value="computer">
   </xsd:enumeration>
   <xsd:enumeration value="navigation">
   </xsd:enumeration>
   <xsd:enumeration value="interactive">
   </xsd:enumeration>
  </xsd:restriction>
 </xsd:simpleType>
 <xsd:element name="datatype">
  <xsd:complexType>
   <xsd:sequence>
    <xsd:element minOccurs="0" maxOccurs="1" ref="dynamic">
    </xsd:element>
    <xsd:element minOccurs="0" maxOccurs="1" ref="user">
    </xsd:element>
    <xsd:element minOccurs="0" maxOccurs="1" ref="thirdparty">
    </xsd:element>
    <xsd:element minOccurs="0" maxOccurs="1" ref="business">
    </xsd:element>
   </xsd:sequence>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="dynamic">
  <xsd:complexType mixed="true">
   <xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="clickstream">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="navigation|computer|demographic" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="http">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="navigation|computer" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="clientevents">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="navigation" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="cookies">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded" type="allCategories" />
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="searchtext">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="interactive" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="interactionrecord">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="interactive" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="miscdata">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded" type="allCategories" />
     </xsd:sequence>
    </xsd:choice>
   </xsd:choice>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="clickstream">
  <xsd:annotation>
   <xsd:documentation>
    Click-stream Information
   </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType>
   <xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="uri">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="navigation" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="timestamp">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="navigation" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="clientip">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded" type="allCategories" />
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="other.httpmethod">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="navigation" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="other.bytes">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="navigation" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="other.statuscode">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="navigation" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
   </xsd:choice>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="http">
  <xsd:annotation>
   <xsd:documentation>
   HTTP Protocol Information 
   </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType>
   <xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="referer">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="navigation" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="useragent">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="computer" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
   </xsd:choice>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="clientevents">
  <xsd:annotation>
   <xsd:documentation>
    User's Interaction with a Resource
   </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType mixed="true">
   <xsd:sequence>
    <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
     <xsd:simpleType>
      <xsd:restriction base="allCategories">
       <xsd:pattern value="navigation" />
      </xsd:restriction>
     </xsd:simpleType>
    </xsd:element>
   </xsd:sequence>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="cookies">
  <xsd:annotation>
   <xsd:documentation>
    Use of HTTP Cookies
   </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType mixed="true">
   <xsd:sequence>
    <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded" type="allCategories" />
   </xsd:sequence>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="searchtext">
  <xsd:annotation>
  <xsd:documentation>
    Search Terms 
  </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType mixed="true">
   <xsd:sequence>
    <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
     <xsd:simpleType>
      <xsd:restriction base="allCategories">
       <xsd:pattern value="interactive" />
      </xsd:restriction>
     </xsd:simpleType>
    </xsd:element>
   </xsd:sequence>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="interactionrecord">
  <xsd:annotation>
   <xsd:documentation>
   Server Stores the Transaction History 
   </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType mixed="true">
   <xsd:sequence>
    <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
     <xsd:simpleType>
      <xsd:restriction base="allCategories">
       <xsd:pattern value="interactive" />
      </xsd:restriction>
     </xsd:simpleType>
    </xsd:element>
   </xsd:sequence>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="miscdata">
  <xsd:annotation>
   <xsd:documentation>
   Miscellaneous Non-base Data Schema = information 
   </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType mixed="true">
   <xsd:sequence>
    <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded" type="allCategories" />
   </xsd:sequence>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="uri">
  <xsd:annotation>
   <xsd:documentation>
   URI of Requested Resource 
   </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType>
   <xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="authority">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded" type="allCategories" />
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="stem">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded" type="allCategories" />
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="querystring">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded" type="allCategories" />
     </xsd:sequence>
    </xsd:choice>
   </xsd:choice>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="timestamp">
  <xsd:annotation>
   <xsd:documentation>
   Request Timestamp 
   </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType>
   <xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="ymd.year">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded" type="allCategories" />
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="ymd.month">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded" type="allCategories" />
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="ymd.day">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded" type="allCategories" />
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="hms.hour">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded" type="allCategories" />
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="hms.minute">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded" type="allCategories" />
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="hms.second">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded" type="allCategories" />
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="fractionsecond">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded" type="allCategories" />
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="timezone">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded" type="allCategories" />
     </xsd:sequence>
    </xsd:choice>
   </xsd:choice>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="clientip">
  <xsd:annotation>
   <xsd:documentation>
   Client's IP Address or Hostname 
   </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType>
   <xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="hostname">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="computer" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="partialhostname">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="demographic" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="fullip">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="computer" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="partialip">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="demographic" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
   </xsd:choice>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="other.httpmethod">
  <xsd:annotation>
   <xsd:documentation>
   HTTP Request Method 
   </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType mixed="true">
   <xsd:sequence>
    <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
     <xsd:simpleType>
      <xsd:restriction base="allCategories">
       <xsd:pattern value="navigation" />
      </xsd:restriction>
     </xsd:simpleType>
    </xsd:element>
   </xsd:sequence>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="other.bytes">
  <xsd:annotation>
   <xsd:documentation>
     Data Bytes in Response 
   </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType mixed="true">
   <xsd:sequence>
    <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
     <xsd:simpleType>
      <xsd:restriction base="allCategories">
       <xsd:pattern value="navigation" />
      </xsd:restriction>
     </xsd:simpleType>
    </xsd:element>
   </xsd:sequence>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="other.statuscode">
  <xsd:annotation>
   <xsd:documentation>
     Response Status Code 
   </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType mixed="true">
   <xsd:sequence>
    <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
     <xsd:simpleType>
      <xsd:restriction base="allCategories">
       <xsd:pattern value="navigation" />
      </xsd:restriction>
     </xsd:simpleType>
    </xsd:element>
   </xsd:sequence>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="referer">
  <xsd:annotation>
   <xsd:documentation>
     Last URI Requested by the User 
   </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType>
   <xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="authority">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded" type="allCategories" />
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="stem">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded" type="allCategories" />
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="querystring">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded" type="allCategories" />
     </xsd:sequence>
    </xsd:choice>
   </xsd:choice>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="useragent">
  <xsd:annotation>
   <xsd:documentation>
     User Agent Information 
   </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType mixed="true">
   <xsd:sequence>
    <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
     <xsd:simpleType>
      <xsd:restriction base="allCategories">
       <xsd:pattern value="computer" />
      </xsd:restriction>
     </xsd:simpleType>
    </xsd:element>
   </xsd:sequence>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="authority">
  <xsd:annotation>
   <xsd:documentation>
     URI Authority 
   </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType mixed="true">
   <xsd:sequence>
    <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded" type="allCategories" />
   </xsd:sequence>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="stem">
  <xsd:annotation>
   <xsd:documentation>
     URI Stem 
   </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType mixed="true">
   <xsd:sequence>
    <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded" type="allCategories" />
   </xsd:sequence>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="querystring">
  <xsd:annotation>
   <xsd:documentation>
     Query-string Portion of URI 
   </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType mixed="true">
   <xsd:sequence>
    <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded" type="allCategories" />
   </xsd:sequence>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="ymd.year">
  <xsd:annotation>
   <xsd:documentation>
     Year 
   </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType mixed="true">
   <xsd:sequence>
    <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded" type="allCategories" />
   </xsd:sequence>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="ymd.month">
  <xsd:annotation>
   <xsd:documentation>
     Month 
   </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType mixed="true">
   <xsd:sequence>
    <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded" type="allCategories" />
   </xsd:sequence>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="ymd.day">
  <xsd:annotation>
   <xsd:documentation>
     Day 
   </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType mixed="true">
   <xsd:sequence>
    <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded" type="allCategories" />
   </xsd:sequence>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="hms.hour">
  <xsd:annotation>
   <xsd:documentation>
     Hour 
   </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType mixed="true">
   <xsd:sequence>
    <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded" type="allCategories" />
   </xsd:sequence>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="hms.minute">
  <xsd:annotation>
   <xsd:documentation>
     Minutes 
   </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType mixed="true">
   <xsd:sequence>
    <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded" type="allCategories" />
   </xsd:sequence>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="hms.second">
  <xsd:annotation>
   <xsd:documentation>
     Second 
   </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType mixed="true">
   <xsd:sequence>
    <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded" type="allCategories" />
   </xsd:sequence>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="fractionsecond">
  <xsd:annotation>
   <xsd:documentation>
     Fraction of Second 
   </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType mixed="true">
   <xsd:sequence>
    <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded" type="allCategories" />
   </xsd:sequence>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="timezone">
  <xsd:annotation>
   <xsd:documentation>
     Time Zone 
   </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType mixed="true">
   <xsd:sequence>
    <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded" type="allCategories" />
   </xsd:sequence>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="hostname">
  <xsd:annotation>
   <xsd:documentation>
     Complete Host and Domain Name 
   </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType mixed="true">
   <xsd:sequence>
    <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
     <xsd:simpleType>
      <xsd:restriction base="allCategories">
       <xsd:pattern value="computer" />
      </xsd:restriction>
     </xsd:simpleType>
    </xsd:element>
   </xsd:sequence>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="partialhostname">
  <xsd:annotation>
   <xsd:documentation>
     Partial Hostname 
   </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType mixed="true">
   <xsd:sequence>
    <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
     <xsd:simpleType>
      <xsd:restriction base="allCategories">
       <xsd:pattern value="demographic" />
      </xsd:restriction>
     </xsd:simpleType>
    </xsd:element>
   </xsd:sequence>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="fullip">
  <xsd:annotation>
   <xsd:documentation>
     Full IP Address 
   </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType mixed="true">
   <xsd:sequence>
    <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
     <xsd:simpleType>
      <xsd:restriction base="allCategories">
       <xsd:pattern value="computer" />
      </xsd:restriction>
     </xsd:simpleType>
    </xsd:element>
   </xsd:sequence>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="partialip">
  <xsd:annotation>
   <xsd:documentation>
     Partial IP Address 
   </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType mixed="true">
   <xsd:sequence>
    <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
     <xsd:simpleType>
      <xsd:restriction base="allCategories">
       <xsd:pattern value="demographic" />
      </xsd:restriction>
     </xsd:simpleType>
    </xsd:element>
   </xsd:sequence>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="user">
  <xsd:complexType mixed="true">
   <xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="name">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="physical|demographic" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="bdate">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="demographic" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="login">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="uniqueid" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="cert">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="uniqueid" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="gender">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="demographic" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="jobtitle">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="demographic" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="home-info">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="physical|online|demographic" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="business-info">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="physical|online|demographic" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="employer">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="demographic" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="department">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="demographic" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
   </xsd:choice>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="name">
  <xsd:annotation>
   <xsd:documentation>
     User's Name 
   </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType>
   <xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="prefix">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="demographic" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="given">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="physical" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="middle">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="physical" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="family">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="physical" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="suffix">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="demographic" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="nickname">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="demographic" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
   </xsd:choice>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="bdate">
  <xsd:annotation>
   <xsd:documentation>
     User's Birth Date 
   </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType>
   <xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="ymd.year">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded" type="allCategories" />
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="ymd.month">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded" type="allCategories" />
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="ymd.day">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded" type="allCategories" />
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="hms.hour">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded" type="allCategories" />
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="hms.minute">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded" type="allCategories" />
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="hms.second">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded" type="allCategories" />
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="fractionsecond">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded" type="allCategories" />
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="timezone">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded" type="allCategories" />
     </xsd:sequence>
    </xsd:choice>
   </xsd:choice>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="login">
  <xsd:annotation>
   <xsd:documentation>
     User's Login Information 
   </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType>
   <xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="id">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="uniqueid" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="password">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="uniqueid" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
   </xsd:choice>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="cert">
  <xsd:annotation>
   <xsd:documentation>
     User's Identity Certificate 
   </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType>
   <xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="key">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="uniqueid" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="format">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="uniqueid" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
   </xsd:choice>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="gender">
  <xsd:annotation>
   <xsd:documentation>
     User's Gender 
   </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType mixed="true">
   <xsd:sequence>
    <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
     <xsd:simpleType>
      <xsd:restriction base="allCategories">
       <xsd:pattern value="demographic" />
      </xsd:restriction>
     </xsd:simpleType>
    </xsd:element>
   </xsd:sequence>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="jobtitle">
  <xsd:annotation>
   <xsd:documentation>
     User's Job Title 
   </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType mixed="true">
   <xsd:sequence>
    <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
     <xsd:simpleType>
      <xsd:restriction base="allCategories">
       <xsd:pattern value="demographic" />
      </xsd:restriction>
     </xsd:simpleType>
    </xsd:element>
   </xsd:sequence>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="home-info">
  <xsd:annotation>
   <xsd:documentation>
     User's Home Contact Information 
   </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType>
   <xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="postal">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded" type="allCategories" />
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="telecom">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="physical" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="online">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="online" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
   </xsd:choice>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="business-info">
  <xsd:annotation>
   <xsd:documentation>
     User's Business Contact Information 
   </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType>
   <xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="postal">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded" type="allCategories" />
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="telecom">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="physical" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="online">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="online" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
   </xsd:choice>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="employer">
  <xsd:annotation>
   <xsd:documentation>
     Name of User's Employer 
   </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType mixed="true">
   <xsd:sequence>
    <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
     <xsd:simpleType>
      <xsd:restriction base="allCategories">
       <xsd:pattern value="demographic" />
      </xsd:restriction>
     </xsd:simpleType>
    </xsd:element>
   </xsd:sequence>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="department">
  <xsd:annotation>
   <xsd:documentation>
     Department or Division of Organization where User is Employed 
   </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType mixed="true">
   <xsd:sequence>
    <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
     <xsd:simpleType>
      <xsd:restriction base="allCategories">
       <xsd:pattern value="demographic" />
      </xsd:restriction>
     </xsd:simpleType>
    </xsd:element>
   </xsd:sequence>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="prefix">
  <xsd:annotation>
   <xsd:documentation>
     Name Prefix 
   </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType mixed="true">
   <xsd:sequence>
    <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
     <xsd:simpleType>
      <xsd:restriction base="allCategories">
       <xsd:pattern value="demographic" />
      </xsd:restriction>
     </xsd:simpleType>
    </xsd:element>
   </xsd:sequence>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="given">
  <xsd:annotation>
   <xsd:documentation>
     Given Name (First Name) 
   </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType mixed="true">
   <xsd:sequence>
    <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
     <xsd:simpleType>
      <xsd:restriction base="allCategories">
       <xsd:pattern value="physical" />
      </xsd:restriction>
     </xsd:simpleType>
    </xsd:element>
   </xsd:sequence>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="middle">
  <xsd:annotation>
   <xsd:documentation>
     Middle Name 
   </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType mixed="true">
   <xsd:sequence>
    <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
     <xsd:simpleType>
      <xsd:restriction base="allCategories">
       <xsd:pattern value="physical" />
      </xsd:restriction>
     </xsd:simpleType>
    </xsd:element>
   </xsd:sequence>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="family">
  <xsd:annotation>
   <xsd:documentation>
     Family Name (Last Name) 
   </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType mixed="true">
   <xsd:sequence>
    <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
     <xsd:simpleType>
      <xsd:restriction base="allCategories">
       <xsd:pattern value="physical" />
      </xsd:restriction>
     </xsd:simpleType>
    </xsd:element>
   </xsd:sequence>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="suffix">
  <xsd:annotation>
   <xsd:documentation>
     Name Suffix 
   </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType mixed="true">
   <xsd:sequence>
    <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
     <xsd:simpleType>
      <xsd:restriction base="allCategories">
       <xsd:pattern value="demographic" />
      </xsd:restriction>
     </xsd:simpleType>
    </xsd:element>
   </xsd:sequence>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="nickname">
  <xsd:annotation>
   <xsd:documentation>
     Nickname 
   </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType mixed="true">
   <xsd:sequence>
    <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
     <xsd:simpleType>
      <xsd:restriction base="allCategories">
       <xsd:pattern value="demographic" />
      </xsd:restriction>
     </xsd:simpleType>
    </xsd:element>
   </xsd:sequence>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="id">
  <xsd:annotation>
   <xsd:documentation>
     Login ID 
   </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType mixed="true">
   <xsd:sequence>
    <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
     <xsd:simpleType>
      <xsd:restriction base="allCategories">
       <xsd:pattern value="uniqueid" />
      </xsd:restriction>
     </xsd:simpleType>
    </xsd:element>
   </xsd:sequence>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="password">
  <xsd:annotation>
   <xsd:documentation>
     Login Password 
   </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType mixed="true">
   <xsd:sequence>
    <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
     <xsd:simpleType>
      <xsd:restriction base="allCategories">
       <xsd:pattern value="uniqueid" />
      </xsd:restriction>
     </xsd:simpleType>
    </xsd:element>
   </xsd:sequence>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="key">
  <xsd:annotation>
   <xsd:documentation>
     Certificate key 
   </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType mixed="true">
   <xsd:sequence>
    <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
     <xsd:simpleType>
      <xsd:restriction base="allCategories">
       <xsd:pattern value="uniqueid" />
      </xsd:restriction>
     </xsd:simpleType>
    </xsd:element>
   </xsd:sequence>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="format">
  <xsd:annotation>
   <xsd:documentation>
     Certificate format 
   </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType mixed="true">
   <xsd:sequence>
    <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
     <xsd:simpleType>
      <xsd:restriction base="allCategories">
       <xsd:pattern value="uniqueid" />
      </xsd:restriction>
     </xsd:simpleType>
    </xsd:element>
   </xsd:sequence>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="postal">
  <xsd:annotation>
   <xsd:documentation>
     Postal Address Information 
   </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType>
   <xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="name">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded" type="allCategories" />
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="street">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="physical" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="city">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="demographic" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="stateprov">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="demographic" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="postalcode">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="demographic" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="organization">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="demographic" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="country">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="demographic" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
   </xsd:choice>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="telecom">
  <xsd:annotation>
   <xsd:documentation>
     Telecommunications Information 
   </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType>
   <xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="telephone">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="physical" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="fax">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="physical" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="mobile">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="physical" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="pager">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="physical" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
   </xsd:choice>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="online">
  <xsd:annotation>
   <xsd:documentation>
     Online Address Information 
   </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType>
   <xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="email">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="online" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="uri">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="online" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
   </xsd:choice>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="street">
  <xsd:annotation>
   <xsd:documentation>
     Street Address 
   </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType mixed="true">
   <xsd:sequence>
    <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
     <xsd:simpleType>
      <xsd:restriction base="allCategories">
       <xsd:pattern value="physical" />
      </xsd:restriction>
     </xsd:simpleType>
    </xsd:element>
   </xsd:sequence>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="city">
  <xsd:annotation>
   <xsd:documentation>
     City 
   </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType mixed="true">
   <xsd:sequence>
    <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
     <xsd:simpleType>
      <xsd:restriction base="allCategories">
       <xsd:pattern value="demographic" />
      </xsd:restriction>
     </xsd:simpleType>
    </xsd:element>
   </xsd:sequence>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="stateprov">
  <xsd:annotation>
   <xsd:documentation>
     State or Province 
   </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType mixed="true">
   <xsd:sequence>
    <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
     <xsd:simpleType>
      <xsd:restriction base="allCategories">
       <xsd:pattern value="demographic" />
      </xsd:restriction>
     </xsd:simpleType>
    </xsd:element>
   </xsd:sequence>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="postalcode">
  <xsd:annotation>
   <xsd:documentation>
     Postal Code 
   </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType mixed="true">
   <xsd:sequence>
    <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
     <xsd:simpleType>
      <xsd:restriction base="allCategories">
       <xsd:pattern value="demographic" />
      </xsd:restriction>
     </xsd:simpleType>
    </xsd:element>
   </xsd:sequence>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="organization">
  <xsd:annotation>
   <xsd:documentation>
     Organization Name 
   </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType mixed="true">
   <xsd:sequence>
    <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
     <xsd:simpleType>
      <xsd:restriction base="allCategories">
       <xsd:pattern value="demographic" />
      </xsd:restriction>
     </xsd:simpleType>
    </xsd:element>
   </xsd:sequence>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="country">
  <xsd:annotation>
   <xsd:documentation>
     Country Name 
   </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType mixed="true">
   <xsd:sequence>
    <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
     <xsd:simpleType>
      <xsd:restriction base="allCategories">
       <xsd:pattern value="demographic" />
      </xsd:restriction>
     </xsd:simpleType>
    </xsd:element>
   </xsd:sequence>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="telephone">
  <xsd:annotation>
   <xsd:documentation>
     Telephone Number 
   </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType>
   <xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="intcode">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="physical" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="loccode">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="physical" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="number">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="physical" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="ext">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="physical" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="comment">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="physical" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
   </xsd:choice>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="fax">
  <xsd:annotation>
   <xsd:documentation>
     Fax Number 
   </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType>
   <xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="intcode">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="physical" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="loccode">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="physical" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="number">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="physical" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="ext">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="physical" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="comment">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="physical" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
   </xsd:choice>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="mobile">
  <xsd:annotation>
   <xsd:documentation>
     Mobile Telephone Number 
   </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType>
   <xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="intcode">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="physical" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="loccode">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="physical" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="number">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="physical" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="ext">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="physical" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="comment">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="physical" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
   </xsd:choice>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="pager">
  <xsd:annotation>
   <xsd:documentation>
     Pager Number 
   </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType>
   <xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="intcode">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="physical" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="loccode">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="physical" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="number">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="physical" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="ext">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="physical" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="comment">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="physical" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
   </xsd:choice>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="email">
  <xsd:annotation>
   <xsd:documentation>
     Email Address 
   </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType mixed="true">
   <xsd:sequence>
    <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
     <xsd:simpleType>
      <xsd:restriction base="allCategories">
       <xsd:pattern value="online" />
      </xsd:restriction>
     </xsd:simpleType>
    </xsd:element>
   </xsd:sequence>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="intcode">
  <xsd:annotation>
   <xsd:documentation>
     International Telephone Code 
   </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType mixed="true">
   <xsd:sequence>
    <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
     <xsd:simpleType>
      <xsd:restriction base="allCategories">
       <xsd:pattern value="physical" />
      </xsd:restriction>
     </xsd:simpleType>
    </xsd:element>
   </xsd:sequence>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="loccode">
  <xsd:annotation>
   <xsd:documentation>
     Local Telephone Area Code 
   </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType mixed="true">
   <xsd:sequence>
    <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
     <xsd:simpleType>
      <xsd:restriction base="allCategories">
       <xsd:pattern value="physical" />
      </xsd:restriction>
     </xsd:simpleType>
    </xsd:element>
   </xsd:sequence>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="number">
  <xsd:annotation>
   <xsd:documentation>
     Telephone Number 
   </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType mixed="true">
   <xsd:sequence>
    <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
     <xsd:simpleType>
      <xsd:restriction base="allCategories">
       <xsd:pattern value="physical" />
      </xsd:restriction>
     </xsd:simpleType>
    </xsd:element>
   </xsd:sequence>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="ext">
  <xsd:annotation>
   <xsd:documentation>
     Telephone Extension 
   </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType mixed="true">
   <xsd:sequence>
    <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
     <xsd:simpleType>
      <xsd:restriction base="allCategories">
       <xsd:pattern value="physical" />
      </xsd:restriction>
     </xsd:simpleType>
    </xsd:element>
   </xsd:sequence>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="comment">
  <xsd:annotation>
   <xsd:documentation>
     Telephone Optional Comments 
   </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType mixed="true">
   <xsd:sequence>
    <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
     <xsd:simpleType>
      <xsd:restriction base="allCategories">
       <xsd:pattern value="physical" />
      </xsd:restriction>
     </xsd:simpleType>
    </xsd:element>
   </xsd:sequence>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="thirdparty">
  <xsd:complexType mixed="true">
   <xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="name">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="physical|demographic" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="bdate">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="demographic" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="login">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="uniqueid" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="cert">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="uniqueid" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="gender">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="demographic" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="jobtitle">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="demographic" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="home-info">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="physical|online|demographic" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="business-info">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="physical|online|demographic" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="employer">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="demographic" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="department">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="demographic" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
   </xsd:choice>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="business">
  <xsd:complexType mixed="true">
   <xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="name">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="demographic" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="department">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="demographic" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="cert">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="uniqueid" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="contact-info">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="physical|online|demographic" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="cert">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="uniqueid" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
   </xsd:choice>
  </xsd:complexType>
 </xsd:element>
 <xsd:element name="contact-info">
  <xsd:annotation>
   <xsd:documentation>
     Contact Information for the Organization </xsd:documentation>
  </xsd:annotation>
  <xsd:complexType>
   <xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="postal">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded" type="allCategories" />
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="telecom">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="physical" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
    <xsd:choice>
     <xsd:element minOccurs="0" maxOccurs="1" ref="online">
     </xsd:element>
     <xsd:sequence>
      <xsd:element name="CATEGORY" minOccurs="0" maxOccurs="unbounded">
       <xsd:simpleType>
        <xsd:restriction base="allCategories">
         <xsd:pattern value="online" />
        </xsd:restriction>
       </xsd:simpleType>
      </xsd:element>
     </xsd:sequence>
    </xsd:choice>
   </xsd:choice>
  </xsd:complexType>
 </xsd:element>
</xsd:schema>

Appendix 2. XSLT to convert old style policies into new style policies

  <?xml version="1.0" encoding="ISO-8859-1"?>

  <!--***********************************************************************

  Written by Giles Hogben,

  Joint Research Center, Ispra Italy.

  Note this Stylesheet uses
  
  ******************************************************************************
  -->

  <xsl:stylesheet version="1.0"
    xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
    xmlns:msxsl="urn:schemas-microsoft-com:xslt"
    xmlns:xs="http://www.w3.org/2001/XMLSchema"
    xmlns:p3p="http://www.w3.org/2002/01/P3Pv1"
    exclude-result-prefixes="msxsl xs xsl p3p">

  <!--***********************************************************************

  Main search and replace template
  
  ******************************************************************************
  -->

    <xsl:template match="@*|*">
      <xsl:choose>
        <xsl:when test="local-name(.)='DATA'">
          <xsl:element name="datatype">
            <xsl:call-template name="StrSplit">
              <xsl:with-param name="str" select="substring-after(@ref,'#')"/>
            </xsl:call-template>
          </xsl:element>
        </xsl:when>
        <xsl:otherwise>
          <xsl:copy>
            <xsl:apply-templates select="@* | * | node()"/>
          </xsl:copy>
        </xsl:otherwise>
      </xsl:choose>
    </xsl:template>

  <!--***********************************************************************

  Split the ref attributes into nested XML
  elements and add the categories and text() nodes at the
  bottom.
  
  ******************************************************************************
  -->

    <xsl:template name="StrSplit">
      <xsl:param name="str" select="/.."/>
        <xsl:choose>
          <xsl:when test="contains($str,'.')">
            <xsl:element name="{substring-before($str,'.')}">
              <xsl:call-template name="StrSplit">
                <xsl:with-param name="str" select="substring-after($str,'.')" />
              </xsl:call-template>
            </xsl:element>
          </xsl:when>
        <xsl:otherwise>
          <xsl:for-each select="./*[local-name()='CATEGORIES']/*">
            <xsl:element name="CATEGORY">
              <xsl:value-of select="local-name()"/>
            </xsl:element>
          </xsl:for-each>
            <xsl:copy-of select="./text()"/>
        </xsl:otherwise>
      </xsl:choose>
    </xsl:template>
  </xsl:stylesheet>

Remaining Issues:

1. For the usage of the BDS to type the address data in the P3P policy ENTITY element, the schema should depart from the previous structure to allow multiple subtypes:

So for example, instead of writing something like:

  <datatype>
    <user>
      <home>
        <contact>
          <postcode>
            21020
          </postcode>
        </contact>
      </home>
    </user>
  </datatype>

  <datatype>
    <user>
      <home>
        <contact>
          <street>
            Mystreet
          </street>
        </contact>
      </home>
    </user>
  </datatype>

  <datatype>
    <user>
      <home>
        <contact>
          <housenumber>
            21
          </housenumber>
        </contact>
      </home>
    </user>
  </datatype>

The policy could express the same thing as follows:

  <datatype>
    <user>
      <home>
        <contact>
          <postcode>
            21020
          </postcode>
          <street>
            Mystreet
          </street>
          <housenumber>
            21
          </housenumber>
        </contact>
      </home>
    </user>
  </datatype>

2.Remove possibility of embedded DS's in policies?

3. Include BDS in P3P NS or make it a separate namespace?