Common Elements: "Kinds"

Introduction

It's often useful for services that use the Google Data APIs to be able to provide a consistent set of information about a particular kind of item.

For example, various Google Data API (or "GData") services might provide contact information for a person or an organization; it makes sense for all such services to use the same set of contact-information elements.

The collection of elements that together describe a contact is called the Contact "kind." Some of the elements in the Contact kind are ordinary Atom or RSS elements; others are defined by Google in a namespace called the "Google Data namespace." By convention, the Google Data namespace is usually referred to in XML code using the gd: alias; for example, the element that contains a telephone or fax number is <gd:phoneNumber>. The schema URL for the Google Data namespace is http://schemas.google.com/g/2005.

Google defines other kinds as well: Event (a collection of standardized elements that together represent a calendar event) and Message (a collection of elements representing an email message, discussion group posting, or other message).

Some elements from the Google Data namespace are used by multiple kinds. For example, the <gd:who> element associates a person (described in the <gd:who>) with the entry that contains the <gd:who> element. This element is used in the Event kind to specify organizers, attendees, and so on. It's also used in the Message kind to specify senders and recipients.

When an entry in a Google Data API feed uses a given kind, it contains an <atom:category> element with its scheme attribute set to "http://schemas.google.com/g/2005#kind" and its term attribute set to the name of the schema URL followed by the name of the kind. For example, a Contact entry includes the following element:

<atom:category scheme="http://schemas.google.com/g/2005#kind"
  term="http://schemas.google.com/g/2005#contact"/>

This allows clients to quickly and easily determine what kind of data the entry contains—that is, to determine the semantics of the entry. (You can use RSS instead of Atom if you prefer; see the protocol reference document for the RSS elements corresponding to Atom elements.)

This document is a reference for some common kinds and the elements they contain.

Undocumented elements

We don't include information about the standard elements of <atom:entry> in kinds where those elements have their standard meanings. For example, <atom:id>, <atom:published>, and <atom:updated> all have their standard meanings when they appear in kinds.

We also don't include information about standard Atom elements that would be meaningless in the given context; for example, <atom:summary> isn't used in the Contact kind, and although <atom:author> is a required element in an entry (unless it's specified in the parent feed), it doesn't have a useful meaning in the Contact kind.

Creating kinds

It may be hard to figure out exactly what information you need to include when creating an entry of a particular kind, especially because some elements in the kinds contain other kinds.

One approach that might help is to use the client libraries we provide rather than to try to construct kinds by hand. The client libraries provide various methods for adding and changing data in an entry of a given kind; see the client library documentation for details.

Extensibility

The information in this document doesn't cover all possible properties and attribute values for kinds. Services may extend kinds, so a particular service may use properties and values not included in this document.

Typographical conventions

In the tables in this document, we use the following conventions for required and optional elements:

elementName	Required element
elementName?	Optional element
elementName*	Optional element, multiple instances allowed

Elements and attributes are presented in standard XPath notation.

Contact kind

Represents a contact: a person, a venue such as a club or a restaurant, or an organization.

Category element: <atom:category scheme="http://schemas.google.com/g/2005#kind" term="http://schemas.google.com/contact/2008#contact"/>

Properties

Property	Description
`atom:category`*	Categories. Instances with the `@label` attribute are treated as tags. For information on using the `@scheme` attribute, see note at beginning of this section.
`atom:content`	Notes about the contact.
`atom:link`*	Links to related information. Specifically, `atom:link[@rel='alternate']` links to an HTML page describing the contact.
`atom:title`	Contact's name.
`gd:email`*	Email addresses.
`gd:im`*	IM addresses.
`gd:phoneNumber`*	Phone and fax numbers.
`gd:postalAddress`*	Postal addresses.
`gd:organization`*	Organization.
`gd:extendedProperty`*	Extended property.
`gContact:groupMembershipInfo`*	Group membership information.
`gd:deleted`*	Deleted state of contact entry.

Examples

<entry xmlns='http://www.w3.org/2005/Atom' xmlns:gd='http://schemas.google.com/g/2005'>
  <category scheme='http://schemas.google.com/g/2005#kind' 
      term='http://schemas.google.com/contact/2008#contact'/>
  <title>Elizabeth Bennet</title>
  <content>My good friend, Liz.  A little quick to judge sometimes, but nice girl.</content>
  <gd:email rel='http://schemas.google.com/g/2005#work' primary='true' address='liz@gmail.com'/>
  <gd:email rel='http://schemas.google.com/g/2005#home' address='liz@example.org'/>
  <gd:phoneNumber rel='http://schemas.google.com/g/2005#work' primary='true'>
    (206)555-1212
  </gd:phoneNumber>
  <gd:phoneNumber rel='http://schemas.google.com/g/2005#home'>
    (206)555-1213
  </gd:phoneNumber>
  <gd:phoneNumber rel='http://schemas.google.com/g/2005#mobile'>
    (206) 555-1212
  </gd:phoneNumber>
  <gd:im rel='http://schemas.google.com/g/2005#home' 
      protocol='http://schemas.google.com/g/2005#GOOGLE_TALK' 
      address='liz@gmail.com'/>
  <gd:postalAddress rel='http://schemas.google.com/g/2005#work' primary='true'>
    1600 Amphitheatre Pkwy 
    Mountain View, CA 94043
  </gd:postalAddress>
  <gd:postalAddress rel='http://schemas.google.com/g/2005#home'>
    800 Main Street
    Mountain View, CA 94041
  </gd:postalAddress>
  <gd:organization>
    <gd:orgName>Google, Inc.</gd:orgName>
    <gd:orgTitle>Tech Writer</gd:orgTitle>
  </gd:organization>
</entry>

Event kind

Represents a calendar event. The event location is represented by a Contact kind embedded in (or linked from) a <gd:where> element; the event planners and attendees are represented as Contact kinds embedded in (or linked from) <gd:who> elements.

Category element: <category scheme="http://schemas.google.com/g/2005#kind" term="http://schemas.google.com/g/2005#event"/>

Properties

Property	Description
`atom:author`	Person who created this event.
`atom:category`*	Categories. Instances with the `@label` attribute are treated as tags. For information on using the `@scheme` attribute, see note at beginning of this section.
`atom:content`	Longer description of the event.
`atom:link`*	Links. Specifically, `atom:link[@rel='alternate']` provides a link to an HTML page describing the event.
`atom:title`	Brief title for the event.
`gd:comments`?	Comments feed.
`gd:eventStatus`?	Extensible enum documented below.
`gd:recurrence`?	Recurrence rule.
`gd:transparency`?	Extensible enum documented below, corresponding to the TRANSP property defined in RFC 2445.
`gd:visibility`?	Extensible enum documented below.
`gd:when`*	Event time. The `startTime` and `endTime` attributes must both be set, although for all-day events those attributes are only dates, with no times.
`gd:when/gd:reminder`*	Reminders for the event.
`gd:where`*	Location of the event or nearby necessities such as parking. If a `<gd:where>` element is specified at the feed level, but there's no `<gd:where>` element at the entry level, then the entries inherit the feed-level `<gd:where>` value.
`gd:who`*	People associated with the event: organizer, attendees, speakers, performers, etc.
`gd:who/gd:attendeeStatus`?	Acceptance status.
`gd:who/gd:attendeeType`?	Attendee type: `required` or `optional`.

rel values for gd:where

rel value	Description
`http://schemas.google.com/g/2005#event` or not specified.	Place where the event takes place.
`http://schemas.google.com/g/2005#event.alternate`	A secondary location. For example, a remote site with a videoconference link to the main site.
`http://schemas.google.com/g/2005#event.parking`	Nearby parking lot.

gd:eventStatus values

Value	Description
`http://schemas.google.com/g/2005#event.canceled`	The event has been canceled.
`http://schemas.google.com/g/2005#event.confirmed`	The event is planned.
`http://schemas.google.com/g/2005#event.tentative`	The event is only tentatively scheduled.

gd:visibility values

Value	Description
`http://schemas.google.com/g/2005#event.confidential`	Allow some readers to see the event.
`http://schemas.google.com/g/2005#event.default`	Inherit the behavior from the preferences of the owner of the calendar on which the event appears.
`http://schemas.google.com/g/2005#event.private`	Allow fewest readers to see the event.
`http://schemas.google.com/g/2005#event.public`	Allow most readers to see the event.

gd:transparency values

Value	Description
`http://schemas.google.com/g/2005#event.opaque`	Indicates event consumes time on calendar; event time will be marked as busy in a free/busy search.
`http://schemas.google.com/g/2005#event.transparent`	Indicates event doesn't consume any time on calendar; event time will not be marked as busy in a free/busy search.

Examples

Meeting:

<entry xmlns:gd="http://schemas.google.com/g/2005">
  <category scheme="http://schemas.google.com/g/2005#kind" term="http://schemas.google.com/g/2005#event"/>
  <id>http://mycal.example.com/feeds/jo/home/full/e1a2af06df8a563edf9d32ec9fd61e03f7f3b67b</id>
  <published>2005-01-18T21:00:00Z</published>
  <updated>2006-01-01T00:00:00Z</updated>
  <title>Discuss BazMat API</title>
  <content>We will discuss integrating GData with BazMat.</content>
  <author>
    <name>Jo March</name>
    <email>jo@example.com</email>
  </author>
  <gd:when startTime='2005-01-18T21:00:00Z' endTime='2005-01-18T22:00:00Z'>
    <gd:reminder minutes='15'/>
  </gd:when>
  <gd:where valueString='Building 41, Room X'/>
  <gd:eventStatus value="http://schemas.google.com/g/2005#event.confirmed"/>
  <gd:visibility value="http://schemas.google.com/g/2005#event.public"/>
  <gd:transparency value="http://schemas.google.com/g/2005#event.transparent"/>
</entry>

Online event:

<entry xmlns:gd="http://schemas.google.com/g/2005">
  <category scheme="http://schemas.google.com/g/2005#kind" term="http://schemas.google.com/g/2005#event"/>
  <id>http://mycal.example.com/feeds/jo/home/full/982307e797979879a</id>
  <published>2005-01-18T21:00:00Z</published>
  <updated>2006-01-01T00:00:00Z</updated>
  <title>Online Chess Tournament</title>
  <content/>
  <author>
    <name>Jo March</name>
    <email>jo@example.com</email>
  </author>
  <gd:when startTime='2006-01-24T19:00:00-08:00' endTime='2006-01-24T20:00:00-08:00'>
    <gd:reminder minutes='15'/>
  </gd:when>
  <gd:where>
    <gd:entryLink>
      <entry>
        <category scheme="http://schemas.google.com/g/2005#kind" term="http://schemas.google.com/g/2005#contact"/>
        <id>http://contacts.example.com/jo/GamePhannz</id>
        <published>2005-01-18T21:00:00Z</published>
        <updated>2006-01-01T00:00:00Z</updated>
        <title>GamePhannz Online Game Server</title>
        <link rel="http://schemas.google.com/g/2005#onlineLocation" type="text/html" href="http://gamephannz.example.com/chess/138fd87e"/>
        <content/>
      </entry>
    </gd:entryLink>
  </gd:where>
  <gd:eventStatus value="http://schemas.google.com/g/2005#event.confirmed"/>
  <gd:visibility value="http://schemas.google.com/g/2005#event.public"/>
  <gd:transparency value="http://schemas.google.com/g/2005#event.transparent"/>
</entry>

Message kind

Represents a message, such as an email, a discussion group posting, or a comment.

Category element: <atom:category scheme="http://schemas.google.com/g/2005#kind" term="http://schemas.google.com/g/2005#message"/>

Properties

Property	Description
`atom:category`*	Categories. Instances with the `@label` attribute are treated as tags. For information on using the `@scheme` attribute, see note at beginning of this section. For information on using the `@term` attribute, see table below.
`atom:content`	Message body.
`atom:link`*	Message attachments. Specifically, to upload an attachment, use `<link rel="enclosure">` and put the attachment's content in an Atom media collection.
`atom:title`	Message subject.
`gd:geoPt`?	Geographic location the message was posted from.
`gd:rating`?	Quality rating (as defined by the application).
`gd:who`*	People associated with this message. The exact semantics depends on the `@rel` value. See table below.

Category @term values

All categories below are in the http://schemas.google.com/g/2005 scheme.

Term	Description
`http://schemas.google.com/g/2005#message.chat`	The message is a transcript of a chat session.
`http://schemas.google.com/g/2005#message.inbox`	The message is marked as belonging to the inbox.
`http://schemas.google.com/g/2005#message.sent`	The message is marked as sent.
`http://schemas.google.com/g/2005#message.spam`	The message is considered spam.
`http://schemas.google.com/g/2005#message.starred`	The message is marked as starred.
`http://schemas.google.com/g/2005#message.unread`	The message is unread.

rel values for gd:who

Property	Description
`http://schemas.google.com/g/2005#message.bcc`	Message BCC recipient.
`http://schemas.google.com/g/2005#message.cc`	Message CC recipient.
`http://schemas.google.com/g/2005#message.from`	Message (email or IM) sender.
`http://schemas.google.com/g/2005#message.reply-to`	Intended recipient of a reply message.
`http://schemas.google.com/g/2005#message.to`	Message primary recipient.

Example

Email message:

<entry xmlns:gd="http://schemas.google.com/g/2005">
  <category scheme="http://schemas.google.com/g/2005#kind" term="http://schemas.google.com/g/2005#message"/>
  <category scheme="http://schemas.google.com/g/2005#kind" term="http://schemas.google.com/g/2005#message.sent"/>
  <author>
    <name>Jo March</name>
    <email>jo@example.com</email>
  </author>
  <id>http://mymail.example.com/feeds/jo/home/full/e1a2af06df8a563edf9d32ec9fd61e03f7f3b67b</id>
  <published>2006-01-18T21:00:00Z</published>
  <updated>2006-01-18T21:00:00Z</updated>
  <title>Re: Info?</title>
  <content>Hi, Fritz -- The information you're looking for is on p. 47.</content>
  <gd:who rel="http://schemas.google.com/g/2005#message.from">
    <gd:entryLink href="http://contacts.example.com/jo/Jo"/>
  </gd:who>
  <gd:who rel="http://schemas.google.com/g/2005#message.to">
    <gd:entryLink href="http://contacts.example.com/fritzb/FritzB"/>
  </gd:who>
</entry>

Google Data namespace element reference

The rest of this document consists of reference material for the elements used by the kinds.

Enums
gdCommonProperties
gd:comments
gd:deleted
gd:email
gd:entryLink
gd:extendedProperty
gd:feedLink
gd:geoPt
gd:im
gd:organization
gd:orgName
gd:orgTitle
gd:originalEvent
gd:phoneNumber
gd:postalAddress
gd:rating
gd:recurrence
gd:recurrenceException
gd:reminder
gd:when
gd:where
gd:who

Enums

Some extension elements need to specify properties whose values come from an enumerated set. The general form of such properties is:

<gd:propertyName value="propertyValue">

If the property value comes from the Google Data namespace, it takes the form http://schemas.google.com/g/2005#{kind}.{value}. For example: http://schemas.google.com/g/2005#event.tentative. If the value space is extensible, values may also be in the form of a URI. The recommended form for extended value URIs is {schema URI}#{value}. For example: http://www.example.com/attendeeStatus#AudioConference.

gEnumConstruct =
   attribute value { text },
   anyAttribute*

gdCommonProperties

Common properties used for all Google types. Note that the presence of anyAttribute and anyElement in the schema allows all Google Data namespace elements using common properties to be further extended in any namespace. In particular it's legal to nest any gd element or any Atom/RSS element within any other gd element. This should be done judiciously, and in most cases such use should be documented as an explicit property of the containing gd element type.

Properties

Property	Type	Description
`@xml:base`	`uri`	Standard XML construct for describing base of nested relative URIs.
`@xml:lang`	`text`	Language of nested strings.

Schema

namespace gd = "http://schemas.google.com/g/2005"

gdCommonProperties = {
   atomCommonAttributes,
   anyAttribute*,
   (anyElement*)
}

gd:comments

Contains a comments feed for the enclosing entry (such as a calendar event.).

Properties

Property	Type	Description
`@rel`?	`string`	Type of comments contained within. Currently, there's a distinction between regular comments and reviews.
`gd:feedLink`?	`feedLink`	Comments feed. This feed should implement the Message kind.

rel values

Value	Description
`http://schemas.google.com/g/2005#regular` or not specified	Regular comments (from users).
`http://schemas.google.com/g/2005#reviews`	Professional reviews.

Examples

Comments feed:

<gd:comments>
  <gd:feedLink href="http://example.com/Jo/posts/MyFirstPost/comments" countHint="10">
    <feed>
      <id>http://example.com/Jo/posts/MyFirstPost/comments</id>
      <title>My first post: comments</title>
      ...
      <entry>
         ...
         <content>Good post.</content>
      </entry>
      <entry>
         ...
      </entry>
      ...
    </feed>
  </gd:feedLink>
</gd:comments>

Reviews feed:

<gd:comments rel="http://schemas.google.com/g/2005#reviews">
  <gd:feedLink href="http://example.com/restaurants/SanFrancisco/432432/reviews" countHint="25">
    <feed>
      <id>http://example.com/restaurants/SanFrancisco/432432/reviews</id>
      <title>La Folie reviews</title>
      ...
      <entry>
         ...
         <content>Good food.</content>
         <gd:rating value="5" min="1" max="5"/>
      </entry>
      <entry>
         ...
      </entry>
      ...
    </feed>
  </gd:feedLink>
</gd:comments>

Schema

start = comments

comments =
   element gd:comments {
      gdCommonProperties,
      attribute rel { xs:string }?,
      (feedLink?)
   }

gd:deleted

A marker element that, when present, indicates the containing entry is deleted.

Properties

None.

Schema

start = deleted

deleted =
   element gd:deleted

gd:email

An email address associated with the containing entity (which is usually an entity representing a person or a location).

Properties

Property	Type	Description
`@address`	`xs:string`	Email address.
`@label`?	`xs:string`	A simple string value used to name this email address. It allows UIs to display a label such as "Work", "Personal", "Preferred", etc.
`@rel`?	`xs:string`	A programmatic value that identifies the type of email; see below for details.
`@primary`?	`xs:boolean`	When multiple email extensions appear in a contact kind, indicates which is primary. At most one email may be primary. Default value is `"false"`.

rel values

Value	Description
`http://schemas.google.com/g/2005#home`
`http://schemas.google.com/g/2005#other`	An email address that is neither home nor work. `label` can be used to indicate the actual type.
`http://schemas.google.com/g/2005#work`

Examples

<gd:email address="foo@bar.example.com"/>
<gd:email label="Personal" rel="http://schemas.google.com/g/2005#home" address="fubar@gmail.com" primary="true"/>

Schema

start = email

email =
   element gd:email {
      attribute address { xs:string },
      attribute label { xs:string }?,
      attribute rel { xs:string }?,
      attribute primary { xs:boolean }?
   }

gd:entryLink

Represents a logically nested entry. For example, a <gd:who> representing a contact might have a nested entry from a contact feed.

Properties

Property	Type	Description
`@href`?	`xs:string`	Specifies the entry URI. If the nested entry is embedded and not linked, this attribute may be omitted.
`@readOnly`?	`xs:boolean`	Specifies whether the contained entry is read-only. The default value is `"false"`.
`@rel`?	`xs:string`	Specifies the link relation; allows the service to provide multiple types of entry links for a single entity. Has the same semantics and allowed values as the `rel` attribute of the `<atom:link>` element.
`atom:entry`?	`atomEntry`	Contents of the entry.

Restrictions

Either or both of @href or <atom:entry> must be present.
If atom:entry is not present, the client can fetch the contents from the entry URI in @href. If atom:entry is present, the contents must be the same as what would be retrieved from @href at the time the entry was generated.
When a PUT or a POST contains a <gd:entryLink> and the @href attribute is specified, the attribute's value is used to create a link; if the atom:entry element is also present, it is ignored. If the @href attribute is not specified, then the atom:entry element is either stored as an embedded entry or stored in another feed and linked to. Note that some services may not support all of these options.

Examples

Contact information within <gd:who>:

<gd:who rel="http://schemas.google.com/g/2005#event.attendee" valueString="Jo">
  <gd:entryLink href="http://gmail.com/jo/contacts/Jo">
    <entry>
      <category scheme="http://schemas.google.com/g/2005#kind"
        term="http://schemas.google.com/g/2005#contact"/>
      <id>http://gmail.com/jo/contacts/Jo</id>
      <category term="user-tag" label="Google"/>
      <title>Jo March</title>
      <gd:email address="jo@example.com"/>
      <gd:phoneNumber label="work">(650) 555-1212</gd:phoneNumber>
    </entry>
  </gd:entryLink>
</gd:who>

External reference only (read-only entry):

<gd:who rel="http://schemas.google.com/g/2005#event.attendee" valueString="Jo">
  <gd:entryLink href="http://gmail.com/jo/contacts/Jo" readOnly="true"/>
</gd:who>

Schema

start = entryLink

entryLink =
   element gd:entryLink {
      attribute href { xs:string }?,
      attribute readOnly { xs:boolean }?,
      (atomEntry?)
   }

gd:extendedProperty

Allows you to store a limited amount of custom data as an auxiliary property of the enclosing entity.

Note that the presence of anyForeignElement allows feed to optionally embed any valid XML within gd:extendedProperty element (mutually exclusive with value attribute).

Properties

Property	Type	Description
`@name`	`xs:string`	Specifies the name of the property expressed as a URI. Extended property URIs usually follow the {scheme}#{local-name} convention.
`@value`?	`xs:string`	Property value.

Example

An external identifier for a calendar event:

<gd:extendedProperty name="http://www.example.com/schemas/2007#mycal.id"
  value="1234"></gd:extendedProperty>

Additional xml for contact entry

<gd:extendedProperty name="com.google">
  <some_xml>value</some_xml>
</gd:extendedProperty>

Schema

start = extendedProperty

extendedProperty =
   element gd:extendedProperty {
      attribute name { xs:string },
      attribute value { xs:string } ?,
      (anyForeignElement*)
   }

gd:feedLink

Represents a logically nested feed. For example, a calendar feed might have a nested feed representing all comments on entries.

Properties

Property	Type	Description
`@countHint`?	`xs:unsignedInt`	Hints at the number of entries in the feed. Depending on the implementation, may not be a precise count.
`@href`?	`xs:string`	Specifies the feed URI. If the nested feed is embedded and not linked, this attribute may be omitted.
`@readOnly`?	`xs:boolean`	Specifies whether the contained feed is read-only.
`@rel`?	`xs:string`	Specifies the link relation; allows the service to provide multiple types of feed links for a single entity. Has the same semantics and allowed values as the `rel` attribute of the `<atom:link>` element.
`atom:feed`?	`atomFeed`	Contents of the feed.

Restrictions

Either or both of @href or <atom:feed> must be present.
If atom:feed is not present, the client can fetch the contents from the URI in @href. If it is present, the contents must the same as what would be retrieved from @href at the time the feed was generated.
When a PUT or a POST contains a <gd:feedLink> and the @href attribute is specified, the attribute's value is used to create a link; if the <atom:feed> element is also present, it is ignored. If the @href attribute is not specified, then the <atom:feed> element is stored as an embedded feed. Note that some services may not support all of these options.

Examples

Blogging:

<gd:feedLink href="http://example.com/Jo/posts/MyFirstPost/comments" countHint="10">
    <feed>
      <id>http://example.com/Jo/posts/MyFirstPost/comments</id>
      <title>My first post: comments</title>
      ...
      <entry>
         ...
         <content>Good post.</content>
      </entry>
      <entry>
         ...
      </entry>
      ...
    </feed>
  </gd:feedLink>

External reference only:

<gd:feedLink href="http://example.com/Jo/posts/MyFirstPost/comments"
            countHint="10"/>

Embedded feed within an Atom entry representing a list:

<gd:feedLink>
  <feed>
    <id>cid:1</id>
    <entry>
       <id>cid:1.1</id>
       <content>list item 1</content>
    </entry>
    <entry>
       <id>cid:1.2</id>
       <content>list item 2</content>
    </entry>
  </feed>
</gd:feedLink>

Schema

start = feedLink

feedLink =
   element gd:feedLink {
      attribute href { xs:string }?,
      attribute readOnly { xs:boolean }?,
      attribute countHint { xs:unsignedInt }?,
      (atomFeed?)
   }

gd:geoPt

A geographical location (latitude, longitude, elevation).

Deprecated. This element is deprecated. For geotagging data, use GeoRSS instead.

Properties

Property	Type	Description
`@elev`?	`xs:float`	Elevation in meters. Negative values indicate depths below mean sea level.
`@label`?	`xs:string`	A simple string value used to name this location. It allows UIs to display a label such as "Current Position".
`@lat`	`xs:float`	Latitude in degrees. Positive values mean North, negative values mean South. The range is [-90.0, 90.0].
`@lon`	`xs:float`	Longitude in degrees. Positive values mean East, negative values mean West. The range is [-180.0, 180.0].
`@time`?	`xs:dateTime`	Timestamp.

Examples

<gd:geoPt lat="40.75" lon="-74.0"/>

<gd:geoPt lat="27.98778" lon="86.94444" elev="8850.0"/>

Schema

start = geoPt

geoPt =
   element gd:geoPt {
      attribute label { xs:string }?,
      attribute lat { xs:float },
      attribute lon { xs:float },
      attribute elev { xs:float }?,
      attribute time { xs:dateTime }?
   }

gd:im

An instant messaging address associated with the containing entity.

Properties

Property	Type	Description
`@address`	`xs:string`	IM address.
`@label`?	`xs:string`	A simple string value used to name this IM address. It allows UIs to display a label such as "Work", "Personal", "Preferred", etc.
`@rel`?	`xs:string`	A programmatic value that identifies the type of IM; see below for details.
`@protocol`?	`xs:string`	Identifies the IM network. The value may be either one of the standard values (shown below) or a URI identifying a proprietary IM network.
`@primary`?	`xs:boolean`	When multiple IM extensions appear in a contact kind, indicates which is primary. At most one IM may be primary. Default value is `"false"`.

rel values

Value	Description
`http://schemas.google.com/g/2005#home`
`http://schemas.google.com/g/2005#other`	An IM address that is neither home nor work. `label` can be used to indicate the actual type.
`http://schemas.google.com/g/2005#work`

protocol attribute values

The following table shows some likely possible values for the @protocol attribute.

Value	Description
`http://schemas.google.com/g/2005#AIM`	AOL Instant Messenger protocol
`http://schemas.google.com/g/2005#MSN`	MSN Messenger protocol
`http://schemas.google.com/g/2005#YAHOO`	Yahoo Messenger protocol
`http://schemas.google.com/g/2005#SKYPE`	Skype protocol
`http://schemas.google.com/g/2005#QQ`	QQ protocol
`http://schemas.google.com/g/2005#GOOGLE_TALK`	Google Talk protocol
`http://schemas.google.com/g/2005#ICQ`	ICQ protocol
`http://schemas.google.com/g/2005#JABBER`	Jabber protocol

Examples

An IM address for MSN Messenger:

<gd:im protocol="http://schemas.google.com/g/2005#MSN" address="foo@bar.msn.com" rel="http://schemas.google.com/g/2005#home" primary="true"/>

A user-provided IM address with an unspecified protocol. Such an address is useful for display purposes, but is difficult to handle programmatically.

<gd:im label="Other" address="foo@baz.example.com"/>

Schema

start = im

im =
   element gd:im {
      attribute address { xs:string },
      attribute label { xs:string }?,
      attribute rel { xs:string }?,
      attribute protocol { xs:string }?,
      attribute primary { xs:boolean }?
   }

gd:organization

An organization, typically associated with a contact.

Properties

Property	Type	Description
`@label`?	`xs:string`	A simple string value used to name this organization. It allows UIs to display a label such as "Work", "Volunteer", "Professional Society", etc.
`@rel`?	`xs:string`	A programmatic value that identifies the type of organization.
`@primary`?	`xs:boolean`	When multiple organizations extensions appear in a contact kind, indicates which is primary. At most one organization may be primary. Default value is `"false"`.
`gd:orgName`?	`orgName`	The name of the organization.
`gd:orgTitle`?	`orgTitle`	The title of a person within the organization.

rel values

Value	Description
`http://schemas.google.com/g/2005#other`	An organization that is not work. `label` can be used to indicate the actual type.
`http://schemas.google.com/g/2005#work`

Examples

<gd:organization rel="http://schemas.google.com/g/2005#work" label="Work" primary="true"/>
  <gd:orgName>Google, Inc.</gd:orgName>
  <gd:orgTitle>Tech Writer</gd:orgTitle>
</gd:organization>

Schema

start = organzation

organization =
   element gd:organization {
      attribute label { xs:string }?,
      attribute rel { xs:string }?,
      attribute primary { xs:boolean }?
      orgName?,
      orgTitle?,
   }

gd:orgName

The name of the organization. Must appear within a gd:organization element.

Example

<gd:orgName>Google, Inc.</gd:orgName>

Schema

start = orgName

orgName =
   element gd:orgName { xs:string }

gd:orgTitle

The title of a person within an organization. Must appear within a gd:organization element.

Example

<gd:orgTitle>President and CEO</gd:orgTitle>

Schema

start = orgTitle

orgTitle =
   element gd:orgTitle { xs:string }

gd:originalEvent

Equivalent to the Recurrence ID property specified in section 4.8.4.4 of RFC 2445. Appears in every instance of a recurring event, to identify the original event.

Contains a <gd:when> element specifying the original start time of the instance that has become an exception.

Properties

Property	Type	Description
`@id`	`xs:string`	The event ID for the original event.
`@href`	`xs:string`	The event feed URL for the original event.

Example

Specifying an original event:

<gd:originalEvent id="i8fl1nrv2bl57c1qgr3f0onmgg"

href="http://www.google.com/calendar/feeds/userID/private-magicCookie/full/eventID">
  <gd:when startTime="2006-03-17T22:00:00.000Z"/>
</gd:originalEvent>

Schema

start = originalEvent

originalEvent =
   element gd:originalEvent {
      attribute id { xs:string },
      attribute href { xs:string },
      when
   }

gd:phoneNumber

A phone number associated with the containing entity (which is usually an entity representing a person or a location).

Properties

Property	Type	Description
`@label`?	`xs:string`	A simple string value used to name this phone number. In most cases, `@label` is not necessary as `@rel` uniquely identifies a number and allows UIs to display a proper label such as "Mobile", "Home", "Work", etc. However, in the case where one person has (for example) multiple mobile phones, this property can be used to disambiguate them.
`@rel`?	`xs:string`	A programmatic value that identifies the type of phone number; see below for details.
`@uri`?	`xs:string`	An optional "tel URI" used to represent the number in a formal way, useful for programmatic access, such as a VoIP/PSTN bridge. See RFC 3966 for more information on tel URIs.
`@primary`?	`xs:boolean`	When multiple phone number extensions appear in a contact kind, indicates which is primary. At most one phone number may be primary. Default value is `"false"`.
`text()`	`xs:string`	Human-readable phone number; may be in any telephone number format. Leading and trailing whitespace is insignificant. Newlines within the string are also insignificant, and may be removed or flattened out to a single space.

rel values

Value	Description
`http://schemas.google.com/g/2005#fax`
`http://schemas.google.com/g/2005#home`
`http://schemas.google.com/g/2005#home_fax`
`http://schemas.google.com/g/2005#mobile`
`http://schemas.google.com/g/2005#other`	A special type of number for which no other `rel` value makes sense. For example, a TTY device. `label` can be used to indicate the actual type.
`http://schemas.google.com/g/2005#pager`
`http://schemas.google.com/g/2005#work`
`http://schemas.google.com/g/2005#work_fax`

Examples

Simple phone number entered by a user:

<gd:phoneNumber>(425) 555-8080 ext. 72585</gd:phoneNumber>

Same phone number drawn from a directory:

<gd:phoneNumber rel="http://schemas.google.com/g/2005#work" uri="tel:+1-425-555-8080;ext=52585">
  (425) 555-8080 ext. 52585
</gd:phoneNumber>

Number with a label:

<gd:phoneNumber rel="http://schemas.google.com/g/2005#mobile" label="Personal calls only" uri="tel:+12065551212">
  +1 206 555 1212
</gd:phoneNumber>

Schema

start = phoneNumber

phoneNumber =
   element gd:phoneNumber {
      attribute rel { xs:string }?,
      attribute label { xs:string }?,
      attribute uri { xs:string }?,
      attribute primary { xs:boolean }?,
      (xs:string)
   }

gd:postalAddress

A postal address.

Properties

Property	Type	Description
`@label`?	`xs:string`	A simple string value used to name this address.
`@rel`?	`xs:string`	A programmatic value that identifies the type of postal address; see below for details.
`@primary`?	`xs:boolean`	When multiple postal address extensions appear in a contact kind, indicates which is primary. At most one postal address may be primary. Default value is `"false"`.
`text()`	`xs:string`	The address as text. Leading and trailing whitespace is insignificant. Newlines within the string are significant.

rel values

Value	Description
`http://schemas.google.com/g/2005#home`
`http://schemas.google.com/g/2005#other`	An address which is neither home nor work. `label` can be used to indicate the actual type.
`http://schemas.google.com/g/2005#work`

Examples

<gd:postalAddress>
  500 West 45th Street
  New York, NY 10036
</gd:postalAddress>

Schema

start = postalAddress

postalAddress =
   element gd:postalAddress {
      attribute label { xs:string }?,
      attribute rel { xs:string }?,
      attribute primary { xs:boolean }?,
      (xs:string)
   }

gd:rating

Represents a numeric rating of the enclosing entity, such as a comment. Each rating supplies its own scale, although it may be normalized by a service; for example, some services might convert all ratings to a scale from 1 to 5.

Properties

Property	Type	Description
`@average`?	`xs:float`	Average rating.
`@max`	`xs:int`	The rating scale's maximum value.
`@min`	`xs:int`	The rating scale's minimum value.
`@numRaters`?	`xs:int`	Number of ratings taken into account when computing the average value.
`@rel`?	`xs:string`	Specifies the aspect that's being rated. If not specified, the rating is an overall rating.
`@value`?	`xs:int`	Rating value.

rel values

Value	Description
`http://schemas.google.com/g/2005#overall` or not specified	Overall rating. Higher values mean better ratings.
`http://schemas.google.com/g/2005#price`	Price rating. Higher values mean higher prices.
`http://schemas.google.com/g/2005#quality`	Quality rating. Higher values mean better quality.

Examples

4/5 overall rating:

<gd:rating value="4" min="1" max="5"/>

Most expensive price range rating:

<gd:rating rel="http://schemas.google.com/g/2005#price" value="5" min="1" max="5"/>

Rated by 200 users with an average rating of 4.65 out of 5:

<gd:rating average="4.65" min="1" max="5" numRaters="200"/>

Schema

start = rating

rating =
   element gd:rating {
      gdCommonProperties,
      attribute rel { xs:string }?,
      attribute value { xs:int }?,
      attribute average { xs:float }?,
      attribute min { xs:int },
      attribute max { xs:int },
      attribute numRaters { xs:int }?
   }

gd:recurrence

Represents the dates and times when a recurring event takes place.

The string that defines the recurrence consists of a set of properties, each of which is defined in the iCalendar standard (RFC 2445).

Specifically, the string usually begins with a DTSTART property that indicates the starting time of the first instance of the event, and often a DTEND property or a DURATION property to indicate when the first instance ends. Next come RRULE, RDATE, EXRULE, and/or EXDATE properties, which collectively define a recurring event and its exceptions (but see below). (See section 4.8.5 of RFC 2445 for more information about these recurrence component properties.) Last comes a VTIMEZONE component, providing detailed timezone rules for any timezone ID mentioned in the preceding properties.

Google services like Google Calendar don't generally generate EXRULE and EXDATE properties to represent exceptions to recurring events; instead, they generate <gd:recurrenceException> elements. However, Google services may include EXRULE and/or EXDATE properties anyway; for example, users can import events and exceptions into Calendar, and if those imported events contain EXRULE or EXDATE properties, then Calendar will provide those properties when it sends a <gd:recurrence> element.

Note the the use of <gd:recurrenceException> means that you can't be sure just from examining a <gd:recurrence> element whether there are any exceptions to the recurrence description. To ensure that you find all exceptions, look for <gd:recurrenceException> elements in the feed, and use their <gd:originalEvent> elements to match them up with <gd:recurrence> elements.

Properties

Property	Type	Description
`text()`	`xs:string`	Recurrence description.

Example

A recurring event that takes place every morning from 6:00 to 7:00 a.m., Pacific time, from March 14 through March 21, 2006:

<gd:recurrence>
  DTSTART;TZID=America/Los_Angeles:20060314T060000
  DURATION:PT3600S
  RRULE:FREQ=DAILY;UNTIL=20060321T220000Z
  BEGIN:VTIMEZONE
  TZID:America/Los_Angeles
  X-LIC-LOCATION:America/Los_Angeles
  BEGIN:STANDARD
  TZOFFSETFROM:-0700
  TZOFFSETTO:-0800
  TZNAME:PST
  DTSTART:19671029T020000
  RRULE:FREQ=YEARLY;BYMONTH=10;BYDAY=-1SU
  END:STANDARD
  BEGIN:DAYLIGHT
  TZOFFSETFROM:-0800
  TZOFFSETTO:-0700
  TZNAME:PDT
  DTSTART:19870405T020000
  RRULE:FREQ=YEARLY;BYMONTH=4;BYDAY=1SU
  END:DAYLIGHT
  END:VTIMEZONE
</gd:recurrence>

Schema

start = recurrence

recurrence =
   element gd:recurrence {
      (xs:string)
   }

gd:recurrenceException

Represents an event that's an exception to a recurring event—that is, an instance of a recurring event in which one or more aspects of the recurring event (such as attendance list, time, or location) have been changed.

Contains a <gd:originalEvent> element that specifies the original recurring event that this event is an exception to.

When you change an instance of a recurring event, that instance becomes an exception. Depending on what change you made to it, the exception behaves in either of two different ways when the original recurring event is changed:

If you add, change, or remove comments, attendees, or attendee responses, then the exception remains tied to the original event, and changes to the original event also change the exception.
If you make any other changes to the exception (such as changing the time or location) then the instance becomes "specialized," which means that it's no longer as tightly tied to the original event. If you change the original event, specialized exceptions don't change. But see below.

For example, say you have a meeting every Tuesday and Thursday at 2:00 p.m. If you change the attendance list for this Thursday's meeting (but not for the regularly scheduled meeting), then it becomes an exception. If you change the time for this Thursday's meeting (but not for the regularly scheduled meeting), then it becomes specialized.

Regardless of whether an exception is specialized or not, if you do something that deletes the instance that the exception was derived from, then the exception is deleted. Note that changing the day or time of a recurring event deletes all instances, and creates new ones.

For example, after you've specialized this Thursday's meeting, say you change the recurring meeting to happen on Monday, Wednesday, and Friday. That change deletes all of the recurring instances of the Tuesday/Thursday meeting, including the specialized one.

If a particular instance of a recurring event is deleted, then that instance appears as a <gd:recurrenceException> containing a <gd:entryLink> that has its <gd:eventStatus> set to "http://schemas.google.com/g/2005#event.canceled". (For more information about canceled events, see RFC 2445.)

Properties

Property	Type	Description
`@specialized`	`xs:boolean`	Indicates whether the exception is specialized or not.
`gd:entryLink`	`entryLink`	An Event entry providing the details about the exception.
`gd:originalEvent`	`originalEvent`	The original recurring event that this is an exception to.

Example

An exception to a recurring event (with some pieces replaced by brief italicized identifiers for clarity):

<gd:recurrenceException specialized="true">
  <gd:entryLink>
    <entry>
      <id>i8fl1nrv2bl57c1qgr3f0onmgg_20060317T220000Z</id>
      <published>2006-03-17T23:00:00.000Z</published>
      <updated>2006-03-14T21:33:12.000Z</updated>
      <category scheme="http://schemas.google.com/g/2005#kind"
        term="http://schemas.google.com/g/2005#event"/>
      <title type="text">recurrence</title>
      <content type="text"/>
      <link rel="alternate" type="text/html"
        href="http://www.google.com/calendar/event?eid=idString"
        title="alternate"/>
      <author>
        <name>exception</name>
      </author>
      <gd:eventStatus
        value="http://schemas.google.com/g/2005#event.confirmed"/>
      <gd:comments>
        <gd:feedLink
            href="http://www.google.com/calendar/feeds/userID/private-magicCookie/full/eventID/comments/">
          <feed>
            <updated>2006-03-14T21:36:23.250Z</updated>
            <title type="text">Comments for: recurrence</title>
            <link rel="alternate" type="text/html"
              href="http://www.google.com/calendar/feeds/userID/private-magicCookie/full/eventID/comments/"
              title="alternate"/>
          </feed>
        </gd:feedLink>
      </gd:comments>
      <gd:transparency
        value="http://schemas.google.com/g/2005#event.opaque "/>
      <gd:originalEvent id="i8fl1nrv2bl57c1qgr3f0onmgg"
          href="http://www.google.com/calendar/feeds/userID/private-magicCookie/composite/eventID">
        <gd:when startTime="2006-03-17T22:00:00.000Z"/>
      </gd:originalEvent>
      <gd:where valueString="Home"/>
      <gd:when startTime="2006-03-17T23:00:00.000Z"
        endTime="2006-03-18T00:00:00.000Z"/>
    </entry>
  </gd:entryLink>
</gd:recurrenceException>

Schema

start = recurrenceException

recurrenceException =
   element gd:recurrenceException {
      attribute specialized { xs:boolean },
      (entryLink
       & originalEvent)
   }

gd:reminder

Most often used in: <gd:when>

A time interval, indicating how long before the containing entity's @startTime or @dueTime attribute a reminder should be issued. Alternatively, may specify an absolute time at which a reminder should be issued. Also specifies a notification method, indicating what medium the system should use to remind the user.

Properties

Property	Type	Description
`@absoluteTime`?	`xs:dateTime`	Absolute time at which the reminder should be issued. This is typically used when a user uses a "snooze" feature to delay a previous reminder. If the timezone is not specified, the observer's local time is assumed.
`@method`?	`xs:string`	The notification method the reminder should use. Can have any of the following values: `alert` (causes an alert to appear when a user is viewing the calendar in a browser), `email` (sends the user an email message), or `sms` (sends the user an SMS text message).
`@days`?	`xs:unsignedInt`	Period of time before `gd:when/@startTime` when a reminder should be issued. If the parent entity's target time is a date rather than a specific time, then these attributes are relative to midnight (00:00) on that date.
`@hours`?	`xs:unsignedInt`
`@minutes`?	`xs:unsignedInt`

When you create or edit a <gd:when> entry, use the following conventions to achieve particular results:

To tell the service to use the user's default reminders, include a <gd:reminder> element with no attributes. If you specify a duration but no method attribute, then the service uses the user's default notification methods with the duration you specified.
To tell the service to not issue any reminders for the event (or to remove existing reminders when updating an event), don't include any <gd:reminder> elements.

Restrictions

At most one of @days, @hours, @minutes, or @absoluteTime may be specified. To specify a mixed duration, convert to the most precise unit. For example, to specify 1 hour 30 minutes, use @minutes="90".
You can't use negative values for the attributes (so if you want a reminder to occur after the start time, you must use @absoluteTime).
A given event can't have more than five reminders associated with it.
When you're adding a reminder to an event, if you specify the alert, email, or sms methods, you must also specify a duration.

Examples

A 15-minute reminder for a meeting:

<gd:when startTime="2005-06-06T17:00:00-08:00" endTime="2005-06-06T18:00:00-08:00">
  <gd:reminder minutes="15"/>
</gd:when>

Same meeting as above, but snoozed for 10 minutes after the reminder at 16:45:

<gd:when startTime="2005-06-06T17:00:00-08:00" endTime="2005-06-06T18:00:00-08:00">
  <gd:reminder minutes="15"/>
  <gd:reminder absoluteTime="2005-06-06T16:55:00-08:00"/>
</gd:when>

Schema

start = reminder

reminder =
   element gd:reminder {
      gdCommonProperties,
      attribute absoluteTime { xs:dateTime }?,
      attribute method { xs:string }?,
      attribute days { xs:unsignedInt }?,
      attribute hours { xs:unsignedInt }?,
      attribute minutes { xs:unsignedInt }?
   }

gd:resourceId

An opaque resource identifier, distinct from atom:id as it need not be a valid URI. Some services provide a separate identifier to be used when constructing subsequent requests. Exact usage is service specific.

Example

<gd:resourceId>9749638</gd:resourceId>

Schema

start = resourceId

resourceId =
   element gd:resourceId { xs:string }

gd:when

Represents a period of time or an instant.

Properties

Property	Type	Description
`@endTime`?	`xs:dateTime` or `xs:date`	Describes when the event ends. If the timezone is not specified, the observer's local timezone is assumed.
`@startTime`	`xs:dateTime` or `xs:date`	Describes when the event starts or (for zero-duration events) when it occurs. If the timezone is not specified, the observer's local timezone is assumed.
`@valueString`?	`xs:string`	A simple string value that can be used as a representation of this time period.

Restrictions

It's not possible to mix xs:dateTime with xs:date in startTime/endTime.
If endTime is not specified, then the event is considered to be an instant in time (if @startTime includes a time) or a one-day event (if @startTime is only a date).

Examples

A one-day event:

<gd:when startTime="2005-06-06"/>

Alternative representation of a one-day event:

<gd:when startTime="2005-06-06" endTime="2005-06-07"/>

A two-day event (on June 6 and June 7) with a string description:

<gd:when startTime="2005-06-06" endTime="2005-06-08" valueString="This weekend"/>

A one-hour meeting:

<gd:when startTime="2005-06-06T17:00:00-08:00" endTime="2005-06-06T18:00:00-08:00"/>

A zero-duration event:

<gd:when startTime="2005-06-06T17:00:00-08:00"/>

Schema

start = when

when =
   element gd:when {
      gdCommonProperties,
      attribute startTime { (xs:date | xs:dateTime) },
      attribute endTime { (xs:date | xs:dateTime) }?,
      attribute valueString { xs:string }?
   }

gd:where

A place (such as an event location) associated with the containing entity. The type of the association is determined by the rel attribute; the details of the location are contained in an embedded or linked-to Contact entry.

A <gd:where> element is more general than a <gd:geoPt> element. The former identifies a place using a text description and/or a Contact entry, while the latter identifies a place using a specific geographic location.

Properties

Property	Type	Description
`@label`?	`xs:string`	Specifies a user-readable label to distinguish this location from other locations.
`@rel`?	`xs:string`	Specifies the relationship between the containing entity and the contained location. Possible values (see below) are defined by other elements. For example, `<gd:when>` defines `http://schemas.google.com/g/2005#event`.
`@valueString`?	`xs:string`	A simple string value that can be used as a representation of this location.
`gd:entryLink`?	`entryLink`	Entry representing location details. This entry should implement the Contact kind.

rel values

Value	Description
`http://schemas.google.com/g/2005#event` or not specified	Place where the enclosing event takes place.
`http://schemas.google.com/g/2005#event.alternate`	A secondary location. For example, a remote site with a videoconference link to the main site.
`http://schemas.google.com/g/2005#event.parking`	A nearby parking lot.

Examples

Event location:

<gd:where valueString="Google Cafeteria (Building 40)"/>

More complicated event location:

<gd:where rel="http://schemas.google.com/g/2005#event" valueString="Joe's Pub">
  <gd:entryLink href="http://local.example.com/10018/JoesPub">
    <gd:entry>
      <id>http://local.example.com/10018/JoesPub</id>
      <category scheme="http://schemas.google.com/g/2005#kind" term="http://schemas.google.com/g/2005#contact"/>
      <content>Nice place to listen to jazz music</content>
      <link href="http://www.joespub.com"/>
      <gd:postalAddress>500 West 45th Street, New York, NY 10018</gd:postalAddress>
      <gd:geoPt lat="40.75" lon="-74.0"/>
      <gd:phoneNumber>(212) 555-1212</gd:phoneNumber>
      <gd:email address="info@joespub.com"/>
    </gd:entry>
  </gd:entryLink>
</gd:where>

Event with multiple locations:

<gd:where label="Mountain View Location (main)"
         valueString="Google Cafeteria (Building 40)"/>

<gd:where rel="http://schemas.google.com/g/2005#event.alternate"
         label="New York Location (videoconference)"
         valueString="Metropolis"/>

Schema

start = where

where =
   element gd:where {
      gdCommonProperties,
      attribute rel { xs:string }?,
      attribute label { xs:string }?,
      attribute valueString { xs:string }?,
      (entryLink?)
   }

gd:who

A person associated with the containing entity. The type of the association is determined by the rel attribute; the details about the person are contained in an embedded or linked-to Contact entry.

The <gd:who> element can be used to specify email senders and recipients, calendar event organizers, and so on.

Properties

Property	Type	Description
`@email`?	`xs:string`	Email address. This property is typically used when `<gd:entryLink>` is not specified. The address must comply with RFC 2822, section 3.4.1.
`@rel`?	`xs:string`	Specifies the relationship between the containing entity and the contained person. See below for possible values.
`@valueString`?	`xs:string`	A simple string value that can be used as a representation of this person.
`gd:attendeeStatus`?	`gEnumConstruct`	Status of event attendee. Extensible enum documented below.
`gd:attendeeType`?	`gEnumConstruct`	Type of event attendee. Extensible enum documented below.
`gd:entryLink`?	`entryLink`	Entry representing person details. This entry should implement the Contact kind. In many cases, this entry will come from a contact feed.

rel values

The valid values for @rel depend on which kind the <gd:who> element appears in.

Value	Kind	Description
`http://schemas.google.com/g/2005#event.attendee`	Event	A general meeting/event attendee.
`http://schemas.google.com/g/2005#event.organizer`	Event	Event organizer. An organizer is not necessarily an attendee.
`http://schemas.google.com/g/2005#event.performer`	Event	Performer. Similar to `http://schemas.google.com/g/2005#event.speaker`, but with more emphasis on art than speech delivery.
`http://schemas.google.com/g/2005#event.speaker`	Event	Speaker.
`http://schemas.google.com/g/2005#message.bcc`	Message	Message BCC recipient.
`http://schemas.google.com/g/2005#message.cc`	Message	Message CC recipient.
`http://schemas.google.com/g/2005#message.from`	Message	Message (email or IM) sender.
`http://schemas.google.com/g/2005#message.reply-to`	Message	Intended recipient of a reply message.
`http://schemas.google.com/g/2005#message.to`	Message	Message primary recipient.

gd:attendeeType Values

Value	Description
`http://schemas.google.com/g/2005#event.optional`	Optional attendee.
`http://schemas.google.com/g/2005#event.required`	Required attendee.

gd:attendeeStatus Values

Value	Description
`http://schemas.google.com/g/2005#event.accepted`	Attendee has accepted.
`http://schemas.google.com/g/2005#event.declined`	Attendee has declined.
`http://schemas.google.com/g/2005#event.invited`	Invitation has been sent, but the person has not accepted.
`http://schemas.google.com/g/2005#event.tentative`	Attendee has accepted tentatively.

Examples

Email recipients:

<gd:who rel="http://schemas.google.com/g/2005#message.from" email="jo@example.com"/>
<gd:who rel="http://schemas.google.com/g/2005#message.to" valueString="Elizabeth" email="liz@example.com"/>

Meeting attendee:

<gd:who rel="http://schemas.google.com/g/2005#event.attendee" valueString="Jo">
  <gd:attendeeType value="http://schemas.google.com/g/2005#event.required"/>
  <gd:attendeeStatus value="http://schemas.google.com/g/2005#event.tentative"/>
  <gd:entryLink href="http://gmail.com/jo/contacts/Jo">
    <entry>
      <id>http://gmail.com/jo/contacts/Jo</id>
      <category term="user-tag" label="Google"/>
      <title>Jo March</title>
      <gd:email address="jo@example.com"/>
      <gd:phoneNumber label="work">(650) 555-1212</gd:phoneNumber>
    </entry>
  </gd:entryLink>
</gd:who>

Event organizer:

<gd:who rel="http://schemas.google.com/g/2005#event.organizer" valueString="Receptionist 41"/>

Schema

start = who

who =
   element gd:who {
      gdCommonProperties,
      attribute rel { xs:string }?,
      attribute email { xs:string }?,
      attribute valueString { xsd:string }?,
      (entryLink?
       & element gd:attendeeType { gEnumConstruct }?
       & element gd:attendeeStatus { gEnumConstruct }?)
   }