[1]W3C

      [1] http://www.w3.org/

Voice Browser Call Control: CCXML Version 1.0

W3C Working Draft 19 January 2007

   This version:
          [2]http://www.w3.org/TR/2007/WD-ccxml-20070119/

      [2] http://www.w3.org/TR/2007/WD-ccxml-20070119/

   Latest version:
          [3]http://www.w3.org/TR/ccxml/

      [3] http://www.w3.org/TR/ccxml/

   Previous version:
          [4]http://www.w3.org/TR/2006/WD-ccxml-20061122/

      [4] http://www.w3.org/TR/2006/WD-ccxml-20061122/

   Editor:
          RJ Auburn, Voxeo [5]<rj@voxeo.com>

      [5] mailto:rj@voxeo.com

   [6]Copyright ©2007 [7]W3C^® ([8]MIT, [9]ERCIM, [10]Keio), All Rights
   Reserved. W3C [11]liability, [12]trademark and [13]document use
   rules apply.
     _________________________________________________________

      [6] http://www.w3.org/Consortium/Legal/ipr-notice#Copyright
      [7] http://www.w3.org/
      [8] http://www.csail.mit.edu/
      [9] http://www.ercim.org/
     [10] http://www.keio.ac.jp/
     [11] http://www.w3.org/Consortium/Legal/ipr-notice#Legal_Disclaimer
     [12] http://www.w3.org/Consortium/Legal/ipr-notice#W3C_Trademarks
     [13] http://www.w3.org/Consortium/Legal/copyright-documents

Abstract

   This document describes CCXML, or the Call Control eXtensible Markup
   Language. CCXML is designed to provide telephony call control
   support for dialog systems, such as VoiceXML [14]VOICEXML]. While
   CCXML can be used with any dialog systems capable of handling media,
   CCXML has been designed to complement and integrate with a VoiceXML
   interpreter. Because of this there are many references to VoiceXML's
   capabilities and limitations. There are also details on how VoiceXML
   and CCXML can be integrated. However, it should be noted that the
   two languages are separate and are not required in an implementation
   of either language. For example, CCXML could be integrated with a
   more traditional Interactive Voice Response (IVR) system or a 3GPP
   Media Resource Function (MRF), and VoiceXML or other dialog systems
   could be integrated with other call control systems.

Status of this Document

   This section describes the status of this document at the time of
   its publication. Other documents may supersede this document. A list
   of current W3C publications and the latest revision of this
   technical report can be found in the [15]W3C technical reports index
   at http://www.w3.org/TR/.

     [15] http://www.w3.org/TR/

   This specification describes the Call Control XML (CCXML) markup
   language that is designed to provide telephony call control support
   for VoiceXML or other dialog systems. This document has been
   produced as part of the [16]W3C Voice Browser Activity, following
   the procedures set out for the [17]W3C Process. The authors of this
   document are members of the [18]Voice Browser Working Group ([19]W3C
   Members only).

     [16] http://www.w3.org/Voice/Activity
     [17] http://www.w3.org/Consortium/Process/
     [18] http://www.w3.org/Voice/Group/
     [19] http://cgi.w3.org/MemberAccess/AccessRequest

   This is the Last Call Working Draft of CCXML 1.0. The Last Call
   period is set to last 3 weeks. Therefore comments on the documents
   are welcome until 7 February 2007.

   There are no changes since the [20]previous Working Draft, except
   that this is a Last Call WD.

     [20] http://www.w3.org/TR/2006/WD-ccxml-20061122/

   This document is also available as a non-normative [21]HTML page
   showing the changes since previous revisions. For a detailed list
   please see [22]Appendix F - Changes.

     [21] http://www.w3.org/TR/ccxml/ccxml.html

   An Implementation Report Plan is currently being developed for this
   specification. The Working Group currently expects to require at
   least two independently developed interoperable implementations of
   each required feature, and at least one implementation of each
   feature, in order to exit the next phase of this document, the
   Candidate Recommendation phase. To help the Voice Browser Working
   Group build such a report, reviewers are encouraged to implement
   this specification and to indicate to W3C which features have been
   implemented, and any problems that arose.

   This document is for public review. Comments and discussion are
   welcomed on the public mailing list < [23]www-voice@w3.org >. To
   subscribe, send an email to <[24]www-voice-request@w3. org> with the
   word subscribe in the subject line (include the word unsubscribe if
   you want to unsubscribe). The [25]archive for the list is accessible
   on-line.

     [23] mailto:www-voice@w3.org
     [24] mailto:www-voice-request@w3.org
     [25] http://lists.w3.org/Archives/Public/www-voice/

   Publication as a Working Draft does not imply endorsement by the W3C
   Membership. This is a draft document and may be updated, replaced or
   obsoleted by other documents at any time. It is inappropriate to
   cite this document as other than work in progress.

   This document was produced by a group operating under the [26]5
   February 2004 W3C Patent Policy. W3C maintains a [27]public list of
   any patent disclosures made in connection with the deliverables of
   the group; that page also includes instructions for disclosing a
   patent. An individual who has actual knowledge of a patent which the
   individual believes contains [28]Essential Claim(s) must disclose
   the information in accordance with [29]section 6 of the W3C Patent
   Policy.

     [26] http://www.w3.org/Consortium/Patent-Policy-20040205/
     [27] http://www.w3.org/2004/01/pp-impl/34665/status
     [28] http://www.w3.org/Consortium/Patent-Policy-20040205/#def-essential
     [29] http://www.w3.org/Consortium/Patent-Policy-20040205/#sec-Disclosure

Conventions of this Document

   In this document, the key words "must", "must not", "required",
   "shall", "shall not", "should", "should not", "recommended", "may",
   and "optional" are to be interpreted as described in [30][RFC2119]
   and indicate requirement levels for compliant CCXML implementations.

Table of Contents

     * 1: [31]Introduction
     * 2: [32]Motivation (Informative)
     * 3: [33]Concepts and Architecture
     *
          + 3.1: [34]Event Processing
          + 3.2: [35]Conferencing
          + 3.3: [36]Scripting
          + 3.4: [37]Definitions
          + 3.5: [38]Session Life-Cycle
          +
               o 3.5.1: [39]Startup
               o 3.5.2: [40]Shutdown
               o 3.5.3: [41]Session Life-Cycle Diagrams
     * 4: [42]Simple Examples
          + 4.1: [43]Hello World
          + 4.2: [44]Accept or Reject a Call
          + 4.3: [45]Simple Dialog
     * 5: [46]CCXML Elements Listing
     * 6: [47]Document Control Flow and Execution
     *
          + 6.1: [48]Overview
          + 6.2: [49]Elements
          +
               o 6.2.1: [50]<ccxml>
               o 6.2.2: [51]<meta>
               o 6.2.3: [52]<metadata>
               o 6.2.4: [53]<if>
               o 6.2.5: [54]<elseif>
               o 6.2.6: [55]<else>
               o 6.2.7: [56]<fetch>
               o 6.2.8: [57]<goto>
               o 6.2.9: [58]<createccxml>
               o 6.2.10: [59]<exit>
               o 6.2.11: [60]<log>
          + 6.3: [61]Events
          +
               o 6.3.1: [62]Overview
               o 6.3.2: [63]fetch.done
               o 6.3.3: [64]error.fetch
               o 6.3.4: [65]ccxml.exit
               o 6.3.5: [66]ccxml.loaded
               o 6.3.6: [67]ccxml.kill
               o 6.3.7: [68]ccxml.created
               o 6.3.8: [69]error.createccxml
               o 6.3.9: [70]error.unsupported
     * 7: [71]Dialogs
     *
          + 7.1: [72]Overview
          + 7.2: [73]Elements
          +
               o 7.2.1: [74]<dialogprepare>
               o 7.2.2: [75]<dialogstart>
               o 7.2.3: [76]<dialogterminate>
          + 7.3: [77]Events
          +
               o 7.3.1: [78]Overview
               o 7.3.2: [79]dialog.started
               o 7.3.3: [80]dialog.exit
               o 7.3.4: [81]dialog.disconnect
               o 7.3.5: [82]dialog.transfer
               o 7.3.6: [83]dialog.terminatetransfer
               o 7.3.7: [84]error.dialog
               o 7.3.8: [85]error.dialog.notstarted
               o 7.3.9: [86]blank
               o 7.3.10: [87]dialog.user.*
               o 7.3.11: [88]dialog.prepared
               o 7.3.12: [89]error.dialog.notprepared
          + 7.4: [90]Dialog Object Properties
          + 7.5: [91]Dialog Class
     * 8: [92]Variables and Expressions
     *
          + 8.1: [93]Overview
          + 8.2: [94]Elements
          +
               o 8.2.1: [95]<assign> and <var>
               o 8.2.2: [96]<script>
          + 8.3: [97]Session Variables
          + 8.4: [98]Application Variables
     * 9: [99]Event Handling
     *
          + 9.1: [100]Overview
          + 9.2: [101]Elements
          +
               o 9.2.1: [102]<eventprocessor>
               o 9.2.2: [103]<transition>
               o 9.2.3: [104]<send>
               o 9.2.4: [105]<move>
               o 9.2.5: [106]<cancel>
          + 9.3: [107]Events
          +
               o 9.3.1: [108]error.notallowed
               o 9.3.2: [109]error.semantic
               o 9.3.3: [110]error.send.targetunavailable
               o 9.3.4: [111]error.send.targettypeinvalid
               o 9.3.5: [112]error.send.failed
               o 9.3.6: [113]send.successful
               o 9.3.7: [114]move.successful
               o 9.3.8: [115]cancel.successful
               o 9.3.9: [116]error.move
          + 9.4: [117]Standard Events
          +
               o 9.4.1: [118]Overview
               o 9.4.2: [119]Standard Event Attributes
               o
                    # 9.4.2.1: [120]Overview
                    # 9.4.2.2: [121]Standard Event Attribute Table
               o 9.4.3: [122]Connection Events
               o 9.4.4: [123]Language Events
               o 9.4.5: [124]Error Events
          + 9.5: [125]Error Handling
     * 10: [126]Telephony Operations and Resources
     *
          + 10.1: [127]Overview
          +
               o 10.1.1: [128]Concepts Background (INFORMATIVE)
          + 10.2: [129]Connections
          +
               o 10.2.1: [130]Connection State
               o 10.2.2: [131]Connection Object
               o 10.2.3: [132]Connection Events
               o 10.2.4: [133]Connection Operations
               o 10.2.5: [134]Connection Class
          + 10.3: [135]Conferences
          +
               o 10.3.1: [136]Conference Object Properties
               o 10.3.2: [137]Conference Class
          + 10.4: [138]Bridges
          +
               o 10.4.1: [139]<join> Outcomes
               o 10.4.2: [140]Invariant Examples
               o 10.4.3: [141]Media Endpoint Properties
          + 10.5: [142]Elements
          +
               o 10.5.1: [143]<accept>
               o 10.5.2: [144]<redirect>
               o 10.5.3: [145]<reject>
               o 10.5.4: [146]<createcall>
               o 10.5.5: [147]<createconference>
               o 10.5.6: [148]<destroyconference>
               o 10.5.7: [149]<join>
               o 10.5.8: [150]<unjoin>
               o 10.5.9: [151]<disconnect>
               o 10.5.10: [152]<merge>
          + 10.6: [153]Events
          +
               o 10.6.1: [154]Overview
               o 10.6.2: [155]connection.alerting
               o 10.6.3: [156]connection.progressing
               o 10.6.4: [157]connection.connected
               o 10.6.5: [158]connection.disconnected
               o 10.6.6: [159]connection.redirected
               o 10.6.7: [160]connection.merged
               o 10.6.8: [161]connection.failed
               o 10.6.9: [162]error.connection
               o 10.6.10: [163]connection.signal
               o 10.6.11: [164]conference.created
               o 10.6.12: [165]conference.destroyed
               o 10.6.13: [166]conference.joined
               o 10.6.14: [167]conference.unjoined
               o 10.6.15: [168]error.conference.create
               o 10.6.16: [169]error.conference.destroy
               o 10.6.17: [170]error.conference.join
               o 10.6.18: [171]error.conference.unjoin
               o 10.6.19: [172]connection.merge.failed
               o 10.6.20: [173]error.connection.wrongstate
               o 10.6.21: [174]error.conference
               o 10.6.22: [175]connection.redirect.failed
               o 10.6.23: [176]connection.accept.failed
               o 10.6.24: [177]connection.reject.failed
     * 11: [178]Complex Examples
     *
          + 11.1: [179]Calling Card Application
          + 11.2: [180]Conferencing application
          + 11.3: [181]Personal Assistant
     * Appendix A - [182]Related Work
     * Appendix B - [183]CCXML DTD
     * Appendix C - [184]CCXML Schema
     * Appendix D - [185]VoiceXML 2.0 Integration Details
     * Appendix E - [186]Recommended Telephony Protocol Names
     * Appendix F - [187]Changes
     * Appendix G - [188]Acknowledgments
     * Appendix H - [189]References
     * Appendix J - [190]Conformance
     * Appendix K - [191]Basic HTTP Event I/O Processor
     * Appendix L - [192]Session Creation Event I/O Processor

1: Introduction

   This document describes CCXML, the Call Control eXtensible Markup
   Language. CCXML provides declarative markup to describe telephony
   call control. CCXML is a language that can be used with a dialog
   system such as VoiceXML [193]VOICEXML].

   CCXML can provide a complete telephony service application,
   comprised of Web server CGI compliant application logic, one or more
   CCXML documents to declare and perform call control actions, and to
   control one or more dialog applications that perform user media
   interactions

   Since platforms implementing CCXML may choose to use one of many
   telephony call control definitions (JAIN Call Control [194]JSR021],
   ECMA CSTA [195]CSTA], S.100 [196]S.100], etc.), the call control
   model in CCXML has been designed to be sufficiently abstract so that
   it can accommodate all major definitions. For relatively simple
   types of call control, this abstraction is straightforward. The
   philosophy in this regard has been to "make simple things simple to
   do." Outdial, transfer (redirect), two-party bridging, and many
   forms of multi-party conferences fall within this classification.

   Figure 1 shows the architecture of a telephony implementation
   consisting of four primary components:
     * a caller (along with the telephone network),
     * a dialog system (e.g. a VoiceXML implementation),
     * a conference server used to mix media streams,
     * and the CCXML implementation which manages the Connections
       between the first two components.

   The Telephony Web Application may or may not be integrated with the
   Voice Web Application.

   The Telephony Control and Dialog Control Interfaces may be
   implemented as an API or protocol.

   The components as shown in the figure below represent logical
   functions, and are not meant to imply any particular architecture.

   CCXML architecture overview
   Figure 1

2: Motivation (Informative)

   CCXML is designed to complement dialog systems such as VoiceXML by
   providing advanced telephony functions. It also can be used as a
   third-party call control manager in any telephony system. This
   document contains references to VoiceXML's capabilities and
   limitations, as well as details on how VoiceXML and CCXML can be
   integrated.

   The CCXML specification originated from the desire to handle call
   control requirements that were beyond the scope of the VoiceXML
   specification. The following requirements are addressed by this
   specification:
     * Support for multi-party conferencing, with advanced conference
       and audio control. A conferencing application involves multiple
       participants, and is dependent upon call control to establish
       relationships between those participants.
     * The ability to give each active call leg its own dedicated
       VoiceXML interpreter. For example, in VoiceXML, the second leg
       of a transferred call lacks a VoiceXML interpreter of its own,
       limiting the scope of possible applications.
     * Sophisticated multiple-call handling and control, including the
       ability to place outgoing calls.
     * Handling for a richer class of asynchronous events. Advanced
       telephony operations involve substantial amounts of signals,
       status events, and message-passing. VoiceXML 2.0 does not
       integrate asynchronous "external" events into its
       event-processing model.
     * VoiceXML lacks the external interfaces required to interact with
       an outside call queue, or place calls on behalf of an external
       document server

   CCXML and VoiceXML implementations are not mutually dependent. A
   CCXML implementation may or may not support voice dialogs, or may
   support dialog languages other than VoiceXML.

3: Concepts and Architecture

   A [197]CCXML application consists of a collection of CCXML documents
   that control and manage the objects listed below:
     * CCXML Session: A [198]CCXML session is comprised of an executing
       CCXML document, or sequence of CCXML documents; each
       concurrently executing CCXML document is a separate session, and
       can be uniquely identified and referenced.
     * Connection: [199]Connections can be "call legs" (real-world
       phone connections) or system resources to facilitate interaction
       with a [200]voice dialog. Media streams between
       [201]Connections, or between [202]Connections and
       [203]Conference objects, need to be tracked by the [204]CCXML
       interpreter and will take real system resources, but do not need
       a dedicated identifier because they are identified by their
       endpoints. Ownership of [205]Connections can be moved from one
       session to another using <move>.
     * Conference object: A [206]Conference Object models a resource
       for mixing media streams. In order to accommodate the widest
       range of underlying telephony call control definitions, CCXML
       assumes a separate [207]Conference Object, realizing that this
       abstraction may not have a direct counterpart in all telephony
       platforms. See <createconference> and <destroyconference> for
       further information.
     * Dialog: When active, a Dialog may interact with other
       Connections or Conferences using one-way or two-way media
       streams, often under the control of dialog environment such as
       VoiceXML.

   CCXML programs manipulate these entities through elements defined in
   the CCXML language. They can also send and/or receive asynchronous
   events associated with these entities.

   CCXML programs directly manipulate [208]Connection Objects and
   [209]Conference Objects with various elements in the language, such
   as <accept>, <createconference>, and <join>. CCXML may also receive
   events from [210]Connection and [211]Conference Objects, in the case
   of line signaling, line-status informational messages, or error and
   failure scenarios.

   CCXML programs can start and kill [212]Voice Dialogs using language
   elements. It can receive events from [213]Voice Dialogs, which may
   be standardized events such as dialog.exit, or application-specific
   ones. CCXML can support sending of an event to a [214]Voice Dialog.

   CCXML programs can create other [215]CCXML sessions using
   <createccxml>. This is the only guaranteed control mechanism a
   [216]CCXML Session ever wields over another. Any other interaction
   takes place through the event mechanism. [217]CCXML Sessions can
   both send and receive events between one another.

  3.1: Event Processing

   Telephone applications need to receive and process large numbers of
   events in real-time. These events arrive from outside the program
   itself - either the underlying telephony platform, or from other
   sources of events.

   A CCXML program includes event handlers which are executed when
   certain events arrive. There are mechanisms for passing information
   back and forth between [218]Voice Dialogs (such as VoiceXML) and
   CCXML, but the important points are that CCXML:
     * lives on its own thread, and
     * carries the burden of rapid asynchronous event handling

   Note: References to threads are meant as logical threads and do not
   imply any specific platform implementation.

  3.2: Conferencing

   CCXML provides a powerful and flexible method of creating
   multi-party calls based on the following concepts:
     * Call legs are audio sinks and sources which can be combined to
       form arbitrary networks.
     * A conference is an audio stream that mixes together all the
       speakers' audio outputs. CCXML conference networks allow for
       [219]conference objects, which mix inputs into a single output
       channel.
     * A conference's architecture may be modified dynamically, thus
       allowing for moderation, floor control, mute, etc.
     * Media splitters, which take a single input channel and emit it
       over several outputs, may be used by an implementation to
       realize the CCXML model in a given network environment.
     * Conferencing technology is implementation-dependent. CCXML
       implementations may not support all conferencing features
       mentioned above.

  3.3: Scripting

   The computational semantics of CCXML language is based on the
   ECMAScript Compact Profile (ES-CP, also known as ECMA-327)
   [220]ECMA327]. ES-CP is a strict subset of the third edition of
   ECMA-262 [221]ECMASCRIPT]. Execution efficiency is a primary goal
   of CCXML implementations, and ES-CP was chosen to ensure that CCXML
   implementations can operate in a variety of execution environments
   and without excessive execution overhead.

   The ES-CP document specification states:

     'ECMAScript Compact Profile is a subset of ECMAScript 3rd Edition
     tailored to resource-constrained devices such as battery powered
     embedded devices. Therefore, special attention is paid to
     constraining ECMAScript features that require proportionately
     large amounts of system memory (both for storing and executing the
     ECMAScript language features) and continuous or proportionately
     large amounts of processing power.'

   While CCXML implementations are not necessarily intended for battery
   powered embedded devices, it is intended to be used in large,
   real-time telephony platforms managing thousands of lines. The
   constraints of ES-CP emphasize CCXML's ongoing concern for execution
   efficiency.

   Even though ES-CP tends to be implemented using interpreters, CCXML
   does not require an interpretive implementation. ES-CP can be
   compiled to a target language such as C, and thus in turn to machine
   code, so that CCXML documents which are static can be rendered once
   in machine code. For example, a CCXML implementation, for
   optimization purposes, could translate and compile frequently used
   CCXML documents on their way from the document server to the CCXML
   execution environment in order to avoid multiplying interpretive
   overhead by the number of lines that execute the same document.

   The emphasis on efficiency in CCXML language is also shown by the
   avoidance of requirements which can only be implemented either by
   interpretation or by run-time evaluation.

   The choice of an implementation strategy is up to the CCXML
   implementer and CCXML language is aimed to allow a range of design
   choices in order to accommodate implementations on a wide variety of
   platforms.

   A CCXML implementation MUST support the ECMAScript Compact Profile.

  3.4: Definitions

   The following terms, which are used throughout this specification,
   are defined as:
     * ECMAScript left-hand-side expression - defined in ECMA-262
       [222]ECMASCRIPT] 11.2; this is an expression which produces a
       result to which a value can be assigned; an expression which is
       valid as the left hand operand of an assignment (=) operator;
       Several examples of left-hand-side expressions are as follows
       (left-hand-side expression in red):
<?xml version="1.0" encoding="UTF-8"?>
<ccxml version="1.0" xmlns="http://www.w3.org/2002/09/ccxml">

<script>

var simpleVar;
var aaVar = Object();

simpleVar            = 'Simple Expr';
aaVar[$1\47]          = 'Simple Expr';
aaVar['arrayKey'] = 'Simple Expr';
aaVar             = {callingDevice: 'notSpecified', callCharacteristics
: 'voiceUnitCall'};
</script>

</ccxml>
     * ECMAScript expression - defined in ECMA-262 [223]ECMASCRIPT]
       11.1; this is an expression which produces a value; an
       expression which is valid on the right hand side of an
       assignment operator;
       Several examples of ECMAScript expressions are as follows
       (ECMAScript expression in red):
<?xml version="1.0" encoding="UTF-8"?>
<ccxml version="1.0" xmlns="http://www.w3.org/2002/09/ccxml">

<script>

var simpleVar;
var aaVar = Object();

simpleVar = 'hello world'; // simple string expression
simpleVar = 'hello world'.length; // Calling a method that returns a
                                  // number on the simple string object
simpleVar = 5; // Simple number expression
simpleVar = aaVar[$1\47]; // Associative Array position expression
simpleVar = aaVar['key']; // Associative Array named value expression
simpleVar = myCoolFunction(); // Function return expression
</script>

</ccxml>
     * ECMAScript variable name - defined in ECMA-262 [224]ECMASCRIPT]
       7.6; this is any valid sequence of characters, known as an
       identifier, which can be used as a variable name, a property
       name, or a function name; this does not include any qualifiers,
       such as array or property accessors;
       Several examples of ECMAScript variable names are as follows
       (ECMAScript variable name in red):
<?xml version="1.0" encoding="UTF-8"?>
<ccxml version="1.0" xmlns="http://www.w3.org/2002/09/ccxml">

<script>

var simpleVar;
var arrayVar = Object();

simpleVar            = 'Simple Expr';
arrayVar[$1\47]          = 'Simple Expr';
arrayVar['arrayKey'] = 'Simple Expr';
arrayVar             = {callingDevice: 'notSpecified', callCharacterist
ics: 'voiceUnitCall'};
</script>

</ccxml>
     * Empty ECMAScript object - an object returned by the new Object()
       ECMAScript expression; an object with no properties.
     * CCXML variable name - a variable name, with optional dot
       separated qualification, declared in a CCXML <var> element or
       defined within ECMAScript code using the var keyword.
     * Scope element - a CCXML element which defines a variable scope;
       <ccxml> and <transition> are CCXML scope elements. Variables
       which are defined within a scope element are not visible to
       variables defined in other scope elements.
     * Time interval - CCXML uses the Cascading Style Sheets, Level 2 [
       [225]CSS2 ] time format. Time designations consist of a
       non-negative real number followed by a time unit identifier. The
       time unit identifiers are:
          + ms : milliseconds
          + s : seconds
       Examples include: "3s", "850ms", "0.7s", ".5s" and "+1.5s".
     * CCXML Application/Program - A collection of CCXML documents that
       together create a complete application/program.
     * CCXML Interpreter - The software that processes CCXML documents,
       executes commands and dispatches events. Also referred to as the
       "CCXML Platform".
     * CCXML Platform - An implementation of CCXML for a specific
       network and environment, generally including a CCXML Interpreter
       as a component.
     * CCXML Session - A single instance of a CCXML application. Can
       span multiple documents and phone calls. See [226]Section 3.5
       Session Life-Cycle for details.
     * CCXML Parent Session - The CCXML session that created the
       currently running session using the <createccxml> element.
     * Event - An action or occurrence to which an application can
       respond. Examples of events are incoming phone calls, dialog
       actions or user defined events. Events in CCXML are modeled as
       ECMAScript objects and can contain complex values.
     * Associative array - An associative array (also known as a map,
       lookup table, or dictionary) is an abstract data type composed
       of a collection of keys and a collection of values, where each
       key is associated with one value. Associative arrays in
       ECMAScript are implemented using an Object with sub properties.
     * Class - CCXML Classes are ECMAScript Constructor objects (see
       section 4.2.1 of the ECMAScript specification for more
       information) to help in creating the appropriate type of object
       instances (such as connection, conference and dialog). The
       Constructor object may contain properties that are not inherited
       by children objects (such as Connection.states). The constructor
       object MAY also contain a Prototype property to allow properties
       that are inherited. Platforms MAY choose to add properties to
       classes. By convention, the properties MUST begin with an
       underscore, "_", to identify them as platform-dependent. All
       defined objects in this specification must be initiated via one
       of these classes. An example would be 'MyConnection = new
       Connection()'. Reserved ECMAscript property
       'prototype.constructor' MUST reference the class constructor
       object, so in the example above,
       'MyConnection.prototype.constructor == Connection'. The
       Connection class MUST initiate connection objects, the Dialog
       class MUST initiate dialog objects and the Conference class MUST
       initiate conference objects.

  3.5: Session Life-Cycle

    3.5.1: Startup

   A CCXML session can be started for the following reasons:
     * A new incoming phone call coming into the platform.
     * A CCXML application executing a <createccxml>.
     * An external session launch request coming into the platform.

   To create a CCXML session, the URI for the initial CCXML document
   must be known, along with any fetching parameters affecting how that
   CCXML document is retrieved. For incoming calls, the selection of
   the initial URI and fetching parameters is platform-dependent, and
   MAY be based on information from the incoming call. Sessions created
   via <createccxml> and the session creation event I/O processor
   determine the initial URI and fetching parameters as stated in this
   specification.

   When a session is started due to an incoming call it has ownership
   of the new Connection that caused it to be created. The new CCXML
   session will be responsible for processing the Connection state
   events and performing the Connection actions. If the session was
   started because of a <createccxml>, it will start without ownership
   of any event endpoints. In the case of an external session launch
   the session will not own any event endpoints.

   A CCXML application can determine the reason its session was started
   by evaluating the contents of the session.startupmode session
   variable that is defined in the [227]Session Variables section.

    3.5.2: Shutdown

   A CCXML session can end in one of the following ways:
     * The CCXML application executes an <exit>.
     * An unhandled "error.*" event.
     * An unhandled "ccxml.kill" event.
     * A "ccxml.kill.unconditional" event.

   When a CCXML session ends, all active connections, conferences and
   dialogs that are owned by that session are automatically terminated
   by the platform.

    3.5.3: Session Life-Cycle Diagrams

   The following diagrams illustrate the session life-cycle of several
   different scenarios. These diagrams do not show all possible
   scenarios but rather show some of the most common ones that CCXML
   applications may encounter.

      3.5.3.1: session can live before and after active connections (or
      no connections at all)

   A CCXML session does not necessarily need to have any connections
   associated with it. After starting, a session may acquire
   connections as a result of <createcall> or <move> requests.
   Session lifecycle diagram

      3.5.3.2: connection life shorter than session

   In this example, the session is started due to an incoming call. A
   connection is typically shorter than a session. A session does not
   end when a connection terminates.
   Session lifecycle diagram

      3.5.3.3: session ends, kills all active connections

   When a session ends, any resources, including connections owned by
   that session are terminated.
   Session lifecycle diagram

      3.5.3.4: session can have multiple sequential connections

   A session can have multiple sequential connections
   Session lifecycle diagram

      3.5.3.5: session can have multiple sequential connections and
      multiple concurrent connections

   In addition to having multiple sequential connections, a session can
   have multiple concurrent connections.
   Session lifecycle diagram

      3.5.3.5: move a connection to a newly created session

   A connection can be moved from one CCXML session to another session.
   In the figure below, CCXML session (1) creates a new CCXML session
   (2) via <createccxml>. Then, the connection is moved from the
   original CCXML session to the new session.
   Session lifecycle diagram

      3.5.3.7: move a connection to a "master" session

   A connection can be moved from one CCXML session to another session,
   such as a "master" session.
   Session lifecycle diagram

      3.5.3.8: optional "master" session for inbound call handling

   Implementations MAY, as a platform-specific optimization, choose to
   deliver more than one inbound call to a single "master" session.
   This can be viewed as equivalent to sessions handling incoming calls
   performing a <move>, as described in 3.5.3.7, of the new Connection
   (including the connection.alerting event) to the single "master"
   CCXML session.

   The default inbound call handling behavior for CCXML implementations
   is to create a new CCXML session and deliver the connection.alerting
   event to it. If a platform supports delivery of multiple inbound
   calls to a single session, the way this is configured is
   implementation specific.
   Session lifecycle diagram

      3.5.3.9: ccxml.kill.unconditional event raised

   If at anytime a ccxml.kill.unconditional event is raised by the
   underlying implementation, the CCXML session is immediately
   terminated and all active connections, conferences and dialogs that
   are owned by that session are automatically terminated by the
   platform.
   Session lifecycle diagram

      3.5.3.10: Normal session shutdown requested by the platform

   If at anytime the platform wishes to terminate a CCXML session it
   MUST raise a ccxml.kill event to inform the CCXML application. The
   normal response to this event is for the CCXML application to
   perform any clean up and termination of current active connections,
   conferences or dialogs and then execute an <exit> element.

   If the CCXML application does not respond to the ccml.kill event in
   a timely manner the platform MAY then raise a
   ccxml.kill.unconditional event to immediately terminate the CCXML
   session and all active connections, conferences, and dialogs that
   are owned by the session.
   Session lifecycle diagram

4: Simple Examples

  4.1: Hello World

   This simple CCXML document shows an example of a "hello world"
   application that is started due to an incoming call where the
   application simply assigns a value to a variable, prints a message
   to the platform log and exits:
<?xml version="1.0" encoding="UTF-8"?>
<ccxml version="1.0" xmlns="http://www.w3.org/2002/09/ccxml">
  <eventprocessor>
    <transition event="connection.alerting">
      <var name="MyVariable" expr="'This is a CCXML Variable'"/>
      <log expr="'Hello World. I just made a variable: ' + MyVariable"/
>
      <log expr="'Lets hang up on this incoming call.'"/>
      <exit/>
    </transition>
  </eventprocessor>
</ccxml>

  4.2: Accept or Reject a Call

   This CCXML document shows an example of how to process a incoming
   call event and answer or reject the call based on the phone number
   of the calling party:
<?xml version="1.0" encoding="UTF-8"?>
<ccxml version="1.0" xmlns="http://www.w3.org/2002/09/ccxml">
  <eventprocessor>

    <transition event="connection.alerting">
      <log expr="'The number called is' + event$.connection.remote + '.
'"/>
      <if cond="event$.connection.remote == 'tel:+18315551234'">
        <log expr="'Go away! we do not want to answer the phone.'"/>
        <reject/>
      <else/>
        <log expr="'We like you! We are going to answer the call.'"/>
        <accept/>
      </if>
    </transition>
    <transition event="connection.connected">
      <log expr="'Call was answered,Time to disconnect it.'"/>
      <disconnect/>
    </transition>
    <transition event="connection.disconnected">
      <log expr="'Call has been disconnected. Ending CCXML Session.'"/>
      <exit/>
    </transition>

  </eventprocessor>
</ccxml>

  4.3: Simple Dialog

   This is an example of running a simple VoiceXML dialog from CCXML.
   The application answers an incoming phone call and then connects it
   to a VoiceXML dialog that returns a value that is then logged to the
   platform:

    dialog.ccxml:

<?xml version="1.0" encoding="UTF-8"?>
<ccxml version="1.0" xmlns="http://www.w3.org/2002/09/ccxml">
  <!-- Lets declare our state var -->
  <var name="state0" expr="'init'"/>

  <eventprocessor statevariable="state0">
    <!-- Process the incoming call -->
    <transition state="init" event="connection.alerting">
      <accept/>
    </transition>
    <!-- Call has been answered -->
    <transition state="init" event="connection.connected">
      <log expr="'Houston, we have liftoff.'"/>
      <dialogstart src="'dialog.vxml'"/>
      <assign name="state0" expr="'dialogActive'" />

    </transition>
    <!-- Process the incoming call -->
    <transition state="dialogActive" event="dialog.exit">
      <log expr="'Houston, the dialog returned [' + event$.values.input
 + ']'" />
      <exit />
    </transition>
    <!-- Caller hung up. Lets just go on and end the session -->
    <transition event="connection.disconnected">
      <exit/>
    </transition>
    <!-- Something went wrong. Lets go on and log some info and end the
 call -->
    <transition event="error.*" >
      <log expr="'Houston, we have a problem: (' + event$.reason + ')'"
/>
      <exit/>
    </transition>
  </eventprocessor>
</ccxml>

    dialog.vxml:

<?xml version="1.0"?>
<vxml xmlns="http://www.w3.org/2001/vxml" version="2.0">
  <form id="Form">
    <field name="input" type="digits">
      <prompt>
        Please say some numbers ...
      </prompt>
      <filled>
        <exit namelist="input"/>
      </filled>
    </field>
  </form>
</vxml>

5: CCXML Elements Listing

   [228]<accept> Accept an incoming phone call
   [229]<assign> Assign a variable a value
   [230]<cancel> Cancel a CCXML event timer
   [231]<ccxml> CCXML container element
   [232]<createcall> Make an outbound call
   [233]<createccxml> Create a new CCXML session
   [234]<createconference> Create a multi-party audio conference
   [235]<destroyconference> Destroy a multi-party audio conference
   [236]<dialogprepare> Prepare a dialog for execution
   [237]<dialogstart> Start a dialog session's execution
   [238]<dialogterminate> Stop a dialog session's execution
   [239]<disconnect> Terminate a phone connection
   [240]<else> Used in <if> statements
   [241]<elseif> Used in <if> statements
   [242]<eventprocessor> Block of event-processing statements
   [243]<exit> Ends execution of the CCXML session
   [244]<fetch> Preload a CCXML file
   [245]<goto> Move execution to a new location
   [246]<if> Conditional logic
   [247]<join> Connect two audio sources
   [248]<log> Log to the platform debug log
   [249]<merge> Merge two connections at the network level
   [250]<meta> Override HTTP headers and provide document metadata
   [251]<metadata> Provide document metadata
   [252]<move> Move an event source to another ccxml session
   [253]<redirect> Redirect an incoming call to a new endpoint
   [254]<reject> Reject an incoming phone call
   [255]<script> Run ECMA Script
   [256]<send> Generate an event
   [257]<transition> A single event-processor block
   [258]<unjoin> Disconnect two audio sources
   [259]<var> Declare a variable

6: Document Control Flow and Execution

  6.1: Overview

   A CCXML session begins with the execution of a CCXML document. The
   flow of the execution can be changed with the help of <if>,
   <elseif>, <else>, <fetch>, and <goto>. Most of a CCXML session's
   execution will take place within an <eventprocessor>, which
   processes a stream of incoming events.

   A CCXML session can consist of multiple CCXML documents, traversed
   by use of <goto> and <fetch>.

   A new CCXML session has a new session object (session.*). A CCXML
   session can contain multiple active connections.

   A CCXML session may launch a new CCXML session using <createccxml>.
   The new CCXML session executes in an independent context and
   variable space from the original CCXML session, completely
   independent of the lifetime of the original session. Sessions can
   communicate by sending messages via <send>.

   The CCXML media type application/ccxml+xml is defined in
   [260]RFC4267]

   This media type should be used for a XML document containing CCXML
   content.

  6.2: Elements

   This section details the CCXML elements for control flow and
   execution.

    6.2.1: <ccxml>

      6.2.1.1: Overview

   This is the parent element of a CCXML document and encloses the
   entire CCXML script in a document. When a <ccxml> is executed, its
   child elements are collected logically together at the beginning of
   the document and executed in document order before the target
   <eventprocessor>. This is called document initialization.

   The <ccxml> can designate the CCXML namespace. This can be achieved
   by declaring an xmlns attribute or an attribute with an " xmlns "
   prefix. See [261][XMLNS] for details. Note that when the xmlns
   attribute is used alone, it sets the default namespace for the
   element on which it appears and for any child elements. The
   namespace URI for CCXML is "http://www.w3.org/2002/09/ccxml".

      6.2.1.2: <ccxml> Attribute Details

   Name Required Attribute Constraints Type Default Value Valid Values
   Description
   version true string none 1.0 The version of this CCXML document. The
   initial version number must be 1.0.
   xml:base false valid URL none A valid URL The base URI for this
   document as defined in [262][XML-BASE]. As in [263][HTML], a URI
   which all relative references within the document take as their
   base.

    6.2.2: <meta>

      6.2.2.1: Overview

   The [264]<metadata> and [265]<meta> are containers in which
   information about the document can be placed. The [266]<metadata>
   provides more general and powerful treatment of metadata information
   than [267]<meta> by using a metadata schema.

   A <meta> declaration associates a string to a declared meta property
   or declares " http-equiv " content. Either a name or http-equiv
   attribute is REQUIRED. It is an error to provide both name and
   http-equiv attributes. A content attribute is REQUIRED. The
   http-equiv attribute has a special significance when documents are
   retrieved via HTTP. Although the preferred method of providing HTTP
   header information is by using HTTP header fields, the " http-equiv
   " content MAY be used in situations where the CCXML document author
   is unable to configure HTTP header fields associated with their
   document on the origin server, for example, cache control
   information. Note that, as with <meta> in HTML documents
   [268][HTML], HTTP servers and caches are not REQUIRED to introspect
   the contents of [269]<meta> in CCXML documents and thereby override
   the header values they would send otherwise.

   Informative: This is an example of how [270]<meta> can be included
   in a CCXML document to specify a resource that provides additional
   metadata information and also indicate that the document MUST NOT be
   cached.
<?xml version="1.0" encoding="UTF-8"?>
<ccxml version="1.0"
       xmlns="http://www.w3.org/2002/09/ccxml">
       <meta name="seeAlso"
content="http://example.com/my-ccxml-metadata.xml"/>
       <meta http-equiv="Cache-Control" content="no-cache"/>
</ccxml>

   <meta> is an empty element.

      6.2.2.2: <meta> Attribute Details

   Name Required Attribute Constraints Type Default Value Valid Values
   Description
   name false This attribute must not be specified in conjunction with
   the http-equiv attribute NMTOKEN none seeAlso The NAME of the
   metadata property.
   The seeAlso property must be used to specify a resource that might
   provide additional metadata information about the content.
   Either the name or the http-equiv attribute has to be specified. If
   neither of them is specified, or if both are specified, an
   error.fetch event must be thrown.
   http-equiv false This attribute must not be specified in conjunction
   with the name attribute NMTOKEN none A valid HTTP header The NAME of
   an HTTP response header.
   This attribute has special significance when documents are retrieved
   via HTTP. The http-equiv content may be used in situations where the
   CCXML document author is unable to configure HTTP header fields
   associated with their document on the origin server.
   Either the name or the http-equiv attribute has to be specified. If
   neither of them is specified, or if both are specified, an
   error.fetch event must be thrown.
   content true string none The value of the metadata property.

    6.2.3: <metadata>

      6.2.3.1: Overview

   <metadata> is a container in which information about the document
   can be placed using a metadata language. Although any metadata
   language can be used within [271]<metadata>, it is recommended that
   the Resource Description Format [RDF] be used in conjunction with
   the general metadata properties defined by the Dublin Core Metadata
   Initiative [272][DC].

   RDF [273][RDF-SYNTAX] is a declarative language and provides a
   standard way for using XML to represent metadata in the form of
   statements about properties and relationships of items on the Web. A
   recommended set of generally applicable metadata properties (e.g., "
   title ", " creator ", " subject ", " description ", " copyrights ",
   etc.) is the Dublin Core Metadata Element Set [274][DC], used in the
   example below.

   Document properties declared with [275]<metadata> can use any
   metadata schema.

   Informative: This is an example of how [276]<metadata> can be
   included in a CCXML document using the Dublin Core version 1.0 RDF
   schema [277][DC] describing general document information such as
   title, description, date, and so on:
<?xml version="1.0" encoding="UTF-8"?>
<ccxml version="1.0"
       xmlns="http://www.w3.org/2002/09/ccxml">
  <metadata>
   <rdf:RDF
       xmlns:rdf = "http://www.w3.org/1999/02/22-rdf-syntax-ns#"
       xmlns:dc = "http://purl.org/dc/elements/1.1/">
   <!-- Metadata about CCXML document -->
   <rdf:Description rdf:about="http://www.example.com/meta.ccxml"
       dc:title="Hamlet-like Soliloquy"
       dc:description="Aldine's Soliloquy in the style of Hamlet"
       dc:publisher="W3C"
       dc:language="en"
       dc:date="2002-11-29"
       dc:rights="Copyright 2002 Aldine Turnbet"
       dc:format="application/ccxml+xml" >
       <dc:creator>William Shakespeare</dc:creator>
       <dc:creator>Aldine Turnbet</dc:creator>
   </rdf:Description>
  </rdf:RDF>
 </metadata>
</ccxml>

   The following CCXML elements can occur within the content of
   [278]<metadata> : none .

      6.2.3.2: <metadata> Attribute Details

   Name Required Attribute Constraints Type Default Value Valid Values
   Description
   none none none

    6.2.4: <if>

      6.2.4.1: Overview

   <if> is a container for conditionally executed elements. <else> and
   <elseif> can optionally appear within an <if> as immediate children,
   and serve to partition the elements within an <if>. <else> and
   <elseif> have no content. <else/> is a synonym for <elseif
   cond="true"/>.

   Each partition within an <if> is preceded by an element having a
   cond attribute. The initial partition is preceded by the <if> and
   subsequent partitions by <elseif>s (or <else>s). The first partition
   in document order with a cond that evaluates to true is selected.
   <else> always evaluate to true. A partition MAY be empty.

   If an <if> has no immediate <elseif> or <else> children, the full
   contents of the <if> will be selected when the cond attribute is
   true.

   <else> was chosen to match similar concepts in other languages, and
   supports examples such as
<if cond="...">
  <!-- selected when <if cond> is true -->
  <else/>
    <!-- selected when <if cond> is false -->
  </if>.

   However, <else> is a synonym for <elseif cond="true"/>, so an
   example such as
<if cond="...">
  <!-- selected when <if cond> is true -->
<else/>
  <!-- selected when <if cond> is false -->
<else/>
  <!-- never selected -->
</if>

   is also possible and MUST be interpreted as
<if cond="...">
  <!-- selected when <if cond> is true -->
<elseif cond="true"/>
  <!-- selected when <if cond> is false -->
<elseif cond="true"/>
  <!-- never selected -->
</if>.

   With this definition for <else>, CCXML provides familiar
   if/elseif/else semantics, but conforms to the rules of valid XML
   [279][XML] documents.

      6.2.4.2: <if> Attribute Details

   Name Required Attribute Constraints Type Default Value Valid Values
   Description
   cond true ECMAScript Expression none A valid ECMAScript expression
   An ECMAScript expression which can be evaluated to true or false.

    6.2.5: <elseif>

      6.2.5.1: Overview

   An <elseif> partitions the content of an <if>, and provides a
   condition that determines the selection of the partition it begins.
   <elseif> can appear optionally as an immediate child of an <if>.

      6.2.5.2: <elseif> Attribute Details

   Name Required Attribute Constraints Type Default Value Valid Values
   Description
   cond true ECMAScript Expression none A valid ECMAScript expression
   An ECMAScript expression which can be evaluated to true or false.

    6.2.6: <else>

      6.2.6.1: Overview

   <else> is a synonym for <elseif cond="true"/>.

      6.2.6.2: <else> Attribute Details

   Name Required Attribute Constraints Type Default Value Valid Values
   Description
   none none else is a synonym for elseif cond="true".

    6.2.7: <fetch>

      6.2.7.1: Overview

   <fetch> is used to asynchronously fetch content identified by the
   attributes of the <fetch>. The fetched content may either be a CCXML
   document, or script content. Content that has been acquired using
   <fetch> is accessible through other elements defined by CCXML.
   Execution returns from the element immediately, and the CCXML
   application can continue on while the platform works to fetch the
   identified resource. When the fetch request has been completed, an
   event is generated against the session that initiated the fetch. The
   event is one of fetch.done, which indicates that the identified
   content was fetched successfully, or error.fetch, indicative of a
   failure to fetch the requested content. Note that even if content is
   successfully fetched, errors in processing fetched content (for
   instance, a CCXML document with a syntax error) may result in an
   error.fetch being thrown.

   The fetch request is local to the session that initiated the
   <fetch>, and is referenced through a unique identifier generated by
   the CCXML platform. The application may obtain the unique identifier
   for a fetch request by providing an ECMAScript left-hand-side
   expression in the fetchid attribute when the fetch is performed. The
   fetch identifier can also be obtained as a property of the
   fetch.done event. The application uses the fetch identifier in any
   CCXML elements that reference fetched content, currently <goto> and
   <script>.

   Fetched content has a lifetime that is limited to that of the
   document in which it is fetched. Therefore, following a transition
   to a new CCXML document using <goto>, content fetched in the scope
   of the current document is no longer accessible. Note that this
   should not be taken to preclude platform-level optimizations or
   caching of resources that are fetched multiple times.

   The use of <fetch> to obtain content does not compel the application
   to make use of that content. However, it is wasteful of system
   resources to fetch resources that are not used. Platforms are
   responsible for clearing out unused fetch resources, and may impose
   limits on the resources that can be fetched by a single session.

   The "http" URI scheme MUST be supported by CCXML platforms, the
   "https" protocol should be supported and other URI protocols may be
   supported.

      6.2.7.2: <fetch> Attribute Details

   Name Required Attribute Constraints Type Default Value Valid Values
   Description
   next true ECMAScript Expression none must evaluate to a valid URL An
   ECMAScript expression which returns the URI of the resource to be
   fetched.
   type false ECMAScript Expression application/ccxml+xml
   application/ccxml+xml
   text/ecmascript
   text/javascript An ECMAScript expression which returns a character
   string that specifies the MIME type of the fetched content. Values
   defined by the specification are:

   application/ccxml+xml
          This specifies that the document being fetched must be a
          CCXML document.

   text/ecmascript
          This specifies that the fetched content must be ECMA Script.

   text/javascript
          This specifies that the fetched content must be JAVA Script.

   namelist false Var List none List of ECMAScript Variable names A
   list of zero or more whitespace separated CCXML variable names.
   These variables must be submitted to the web server, with the same
   qualification as used in the namelist. When an ECMAscript variable
   is submitted to the web server, its value must be first converted
   into a string before being submitted.
   If the variable is an ECMAScript Object, the mechanism by which it
   must be submitted is not currently defined. Instead of submitting
   ECMAScript Objects directly, the application developer may
   explicitly submit the properties of an Object. e.g. "date.month
   date.year".
   method false ECMAScript Expression get get
   post An ECMAScript expression which returns a character string that
   indicates the HTTP method to use. Values defined by the
   specification are:

   get
          This indicates that the "GET" method must be used to fetch
          the URL.

   post
          This indicates that the "POST" method must be used while
          submitting the URL to the web server.

   fetchid false ECMAScript Left Hand Side Expression none ECMAScript
   Variable An ECMAScript left hand side expression evaluating to a
   previously defined variable. The value of the attribute must receive
   an internally generated unique string identifier to be associated
   with the completion event. This identifier can be tested by the
   fetch completion event handler to distinguish among several
   outstanding fetch requests.
   If this attribute is not specified, the fetch identifier can be
   acquired from the fetch completion event. Every fetch request must
   receive a unique fetch identifier, even if the request is for the
   same URL.
   timeout false ECMAScript Expression none An ECMAScript expression
   which returns a character string in CSS2 [280][2] format The
   character string returned must be interpreted as a time interval.
   This interval begins when the fetch is executed. The fetch must fail
   if not completed at the end of this interval. A failed fetch must
   return the error.fetch event.
   maxage false ECMAScript Expression none An ECMAScript expression
   which returns a valid time value for the HTTP 1.1 request
   [281][RFC2616] The character string returned must be interpreted as
   a time interval. This indicates that the document is willing to use
   content whose age must be no greater than the specified time in
   seconds (cf. 'max-age' in HTTP 1.1 [282][RFC2616]). The document is
   not willing to use stale content, unless maxstale is also provided.
   maxstale false ECMAScript Expression none An ECMAScript expression
   which returns a valid time value for the HTTP 1.1 request
   [283][RFC2616] The character string returned must be interpreted as
   a time interval. This indicates that the document is willing to use
   content that has exceeded its expiration time (cf. 'max-age' in HTTP
   1.1 [284][RFC2616]). If maxstale is assigned a value, then the
   document is willing to accept content that has exceeded its
   expiration time by no more than the specified number of seconds.
   enctype false Valid only when the value of the method is "post"
   ECMAScript Expression application/x-www-form-urlencoded valid media
   encoding type An ECMAScript expression which returns a character
   string that indicates the media encoding type of the submitted
   document (when the value of the method is "post"). Values defined by
   the specification are:

      [2] http://www.w3.org/TR/2007/WD-ccxml-20070119/

   application/x-www-form-urlencoded
          This indicates that the ccxml variables specified in the
          namelist must be url encoded.

    6.2.8: <goto>

      6.2.8.1: Overview

   <fetch>, in conjunction with <goto>, is used to transfer execution
   to a different CCXML document in a multi-document CCXML application.
   The <fetch> tells the platform to find, load, and parse a given
   CCXML document. After the fetch completes, the CCXML application can
   then issue a <goto> to execute the now-fetched document.

   Below is a small snippet of code from the CCXML application's event
   handler. We execute a <fetch> operation, and continue on to assign
   to a state variable, and maybe handle more events. Eventually, the
   fetch completes, the CCXML platform services the event, and the
   application performs the <goto>.
<fetch next="'http://www.example.com/control.ccxml'"/>
<--control continues here->
<assign name="state_var" expr="'fetch_wait'"/>
</transition>
<!-- ……… -->
<transition state="fetch_wait" event="fetch.done"/>
<goto fetchid="event$.fetchid"/>
</transition>

   A <goto> transfers control to the document obtained through a fetch
   request, using the platform-generated unique identifier associated
   with that fetch request. The fetch completion event MUST have
   arrived before the <goto> is executed, otherwise, an error.semantic
   event is generated. If the fetched content referenced by the fetch
   identifier is not a CCXML document, or the fetch identifier is
   invalid and does not correspond to any fetch request, this also
   results in an error.semantic event.

   When a <goto> is executed, the target document replaces the current
   document in its session. Event sources associated with this session
   are inherited by the target document. Execution of the current
   document terminates.

      6.2.8.2: <goto> Attribute Details

   Name Required Attribute Constraints Type Default Value Valid Values
   Description
   fetchid true ECMAScript Expression none A valid fetch id An
   ECMAScript expression which returns the fetch identifier of a
   completed fetch request acquired either in a fetch with the fetchid
   attribute, or from the fetchid attribute of a fetch.done event.
   If the attribute value is invalid, an error.semantic event must be
   thrown.

      6.2.8.3: <fetch> and <goto> Example

   The following code shows the use of the <fetch> and <goto> elements
   along with the fetchid attribute to handle more complex fetching
   situations:
<?xml version="1.0" encoding="UTF-8"?>
<ccxml version="1.0" xmlns="http://www.w3.org/2002/09/ccxml">

  <!-- var to hold the value of the fetch
          identifier that we care about -->
  <var name="myGoodFetchID"/>

  <eventprocessor>
    <transition event="ccxml.loaded">
       <!-- stick the value of the fetch
               identifier in the myGoodFetchID var -->
       <fetch fetchid="myGoodFetchID"
                 next="'http://www.example.com/goodfetch.ccxml'"/>

       <!-- do not bother saving the fetch id's for these,
               we would just ignore them anyway -->
       <fetch next="'http://www.example.com/fakefetch1.ccxml'"/>
       <fetch next="'http://www.example.com/fakefetch2.ccxml'"/>
    </transition>

    <transition event="fetch.done">
       <if cond="myGoodFetchID == event$.fetchid">
          <!-- only matched if we have fetched
                  http://www.example.com/goodfetch.ccxml -->
          <goto fetchid="event$.fetchid"/>
       </if>
    </transition>

    <transition event="error.fetch">
          <!-- Ignore bad fetches in this example -->
    </transition>

  </eventprocessor>
</ccxml>

    6.2.9: <createccxml>

      6.2.9.1: Overview

   <createccxml> is used to create another CCXML session, which begins
   execution with the document identified by this element. The new
   CCXML session has no relation to its creator once spawned, and has a
   wholly separate lifetime and address space.

   Execution returns from the <createccxml> element immediately, and
   the CCXML interpreter can continue on while the new CCXML session is
   established and loads its initial document. If the new session is
   successfully established or a failure occurs an event is generated
   and is delivered to the session that executed the <createccxml>
   element.

      6.2.9.2 <createccxml> Attribute Details

   Name Required Attribute Constraints Type Default Value Valid Values
   Description
   next true ECMAScript Expression none a valid URL An ECMAScript
   expression which returns the URI of the resource to be fetched.
   namelist false Var List none List of ECMAScript Variable names A
   list of zero or more whitespace separated CCXML variable names.
   These variables must be submitted to the web server, with the same
   qualification as used in the namelist. When an ECMAscript variable
   is submitted to the web server, its value must be first converted
   into a string before being submitted.
   If the variable is an ECMAScript Object, the mechanism by which it
   must be submitted is not currently defined. Instead of submitting
   ECMAScript Objects directly, the application developer may
   explicitly submit the properties of an Object. e.g. "date.month
   date.year".
   fetchparam false ECMAScript expression 'none' 'none', 'session-id',
   'session' Specifies parameters, in addition to those specified via
   'namelist' (if present), that will be passed to the web server when
   fetching the CCXML document for the new session. Three values are
   legal for this attribute:
     * none - No additional parameters should be passed with the fetch;
     * session-id - The 'session.id' property of the newly created
       session will be included when fetching the initial document;
     * session - The 'session.id' property and all properties of
       'session.values' will be included when fetching the initial
       document. The evaluation of 'session.values' will occur after it
       has been populated as per the 'parameter' attribute above,
       providing developers with a simple means of passing data both to
       the new CCXML session and to the web server.

   parameters false Var List none List of ECMAScript Variable names A
   list of zero or more whitespace separated CCXML variable names. Each
   named variable will be created as a property of 'session.values' in
   the newly created session. For instance, passing a variable named
   'foo' with value '123' will result in the 'session.values.foo'
   property evaluating to '123'; similarly, passing a variable named
   'foo.bar' would result in a 'session.values.foo.bar' property.
   Variable values are passed in string form; the passing of ECMAScript
   objects is not currently defined.
   method false ECMAScript Expression get get
   post An ECMAScript expression which returns a character string that
   indicates the HTTP method to use. Values defined by the
   specification are:

   get
          This indicates that the "GET" method must be used to fetch
          the URL.

   post
          This indicates that the "POST" method must be used while
          submitting the URL to the web server.

   sessionid false ECMAScript Left Hand Side Expression none ECMAScript
   Variable An ECMAScript left hand side expression evaluating to a
   previously defined variable. The value of the attribute must receive
   an internally generated unique string identifier which identifies
   the newly created session.
   timeout false ECMAScript Expression none An ECMAScript expression
   which returns a character string in CSS2 [285][2] format The
   character string returned must be interpreted as a time interval.
   This time interval must be interpreted by the new CCXML session as
   the maximum time it may wait for the completion of the fetch for the
   initial document specified by the next attribute. If the new CCXML
   session is unable to fetch the initial document within the timeout
   interval, an error.createccxml event must be thrown.
   maxage false ECMAScript Expression none An ECMAScript expression
   which returns a valid time value for the HTTP 1.1 request
   [286][RFC2616] The character string returned must be interpreted as
   a time interval. This indicates that the document is willing to use
   content whose age must be no greater than the specified time in
   seconds (cf. 'max-age' in HTTP 1.1 [287][RFC2616]). The document is
   not willing to use stale content, unless maxstale is also provided.
   maxstale false ECMAScript Expression none An ECMAScript expression
   which returns a valid time value for the HTTP 1.1 request
   [288][RFC2616] The character string returned must be interpreted as
   a time interval. This indicates that the document is willing to use
   content that has exceeded its expiration time (cf. 'max-age' in HTTP
   1.1 [289][RFC2616]). If maxstale is assigned a value, then the
   document is willing to accept content that has exceeded its
   expiration time by no more than the specified number of seconds.
   enctype false Valid only when the value of the method is "post"
   ECMAScript Expression application/x-www-form-urlencoded valid media
   encoding type An ECMAScript expression which returns a character
   string that indicates the media encoding type of the submitted
   document (when the value of the method is "post"). Values defined by
   the specification are:

      [2] http://www.w3.org/TR/2007/WD-ccxml-20070119/

   application/x-www-form-urlencoded
          This indicates that the ccxml variables specified in the
          namelist must be url encoded.

    6.2.10: <exit>

      6.2.10.1: Overview

   <exit> ends execution of the CCXML session. All pending events are
   discarded, and there is no way to restart CCXML execution.

      6.2.10.2 <exit> Attribute Details

   Name Required Attribute Constraints Type Default Value Valid Values
   Description
   expr false ECMAScript Expression undefined A return ECMAScript
   expression (e.g. 0 or 'oops!'). If this attribute is omitted, the
   return value must be ECMAScript undefined. This value must be stored
   as a property of the exit event.
   namelist false Var List none List of ECMAScript Variable names A
   list of one or more whitespace separated CCXML unqualified variable
   names to be returned. These variable names and their associated
   values must be set as properties of the exit event.

   A CCXML document executing the <exit> will generate a ccxml.exit
   event to the parent session. The exiting document will be identified
   on the exit event by its session ID.

    6.2.11: <log>

      6.2.11.1: Overview

   <log> allows an application to generate a logging or debug message
   which a developer can use to help in application development or
   post-execution analysis of application performance. The manner in
   which the message is displayed or logged is platform-dependent. The
   usage of label is platform-dependent. The use of <log> SHOULD have
   no other side-effects on interpretation. <log>is an empty element.

      6.2.11.2 <log> Attribute Details

   Name Required Attribute Constraints Type Default Value Valid Values
   Description
   label false ECMAScript Expression none An ECMAScript expression
   which returns a character string which must be used, for example, to
   indicate the purpose of the log.
   expr true ECMAScript Expression none An ECMAScript expression
   evaluating to a string to be logged.

  6.3: Events

    6.3.1: Overview

   CCXML allows operations such as document fetching, startup and
   shutdown to execute independently. CCXML events that describe these
   operations are defined below:

    6.3.2: fetch.done - Fetch Completion Event

   This event is generated when a fetch request completes successfully.
   It is delivered to the document which issued the request.

   The fields of this event are:

   Attribute Name Required Type Details
   name true string fetch.done
   fetchid true string The internally generated unique fetch identifier
   uri true string The URI of the resource that was fetched. If the
   fetch resulted in one or more HTTP redirects (e.g. 302), the value
   of this property is set to the final target URI.
   eventid true string The unique identifier for the event. This must
   match the sendid attribute of send, if the event was generated by a
   CCXML document.
   eventsource true string The unique identifier of the event source.
   This identifies the CCXML Event I/O Processor that sent this event.
   eventsourcetype true string The name of the Event I/O Processor that
   sent this event. This must be set to ccxml as this is an event
   generated by the CCXML Session Event processor.
     _________________________________________________________

    6.3.3: error.fetch - Fetch Error Event

   This event is generated when a fetch request does not successfully
   complete. It is delivered to the document which issued the request.

   The fields of this event are:

   Attribute Name Required Type Details
   name true string error.fetch
   fetchid true string The internally generated unique fetch identifier
   reason true string A string description of the fetch error. Content
   of this field is platform-specific.
   statuscode true int The numeric HTTP status code (eg 404,500 etc) of
   the failed HTTP request.
   uri true string The URI of the resource that was fetched. If the
   fetch resulted in one or more HTTP redirects (e.g. 302), the value
   of this property is set to the final target URI.
   eventid true string The unique identifier for the event. This must
   match the sendid attribute of send, if the event was generated by a
   CCXML document.
   eventsource true string The unique identifier of the event source.
   This identifies the CCXML Event I/O Processor that sent this event.
   eventsourcetype true string The name of the Event I/O Processor that
   sent this event. This must be set to ccxml as this is an event
   generated by the CCXML Session Event processor.
     _________________________________________________________

    6.3.4: ccxml.exit - CCXML Document Exit Event

   This event is generated when a CCXML document executes an <exit>,
   having an unhandled "error.*" or ccxml.kill event. This event is
   only generated when the session executing the <exit/> has a parent
   session. This event is sent to the parent session and not the
   session executing the <exit/>.

   The fields of this event are:

   Attribute Name Required Type Details
   name true string ccxml.exit
   sessionid true string The identifier of the exiting session. This
   must be the same value that was returned to the sessionid attribute
   of the createccxml which created this session.
   expr true string The value of the exit expr attribute. If this
   attribute is omitted in the exit, the value must be ECMAScript
   undefined.
   false string valued array
   values.* false ECMAScript Object Return values from the ccxml
   session. This would be the values of each of the objects listed in
   the CCXML exit element's namelist.
   eventid true string The unique identifier for the event. This must
   match the sendid attribute of send, if the event was generated by a
   CCXML document.
   eventsource true string The unique identifier of the event source.
   This identifies the CCXML Event I/O Processor that sent this event.
   eventsourcetype true string The name of the Event I/O Processor that
   sent this event. This must be set to ccxml as this is an event
   generated by the CCXML Session Event processor.
   reason true string Reason that the session ended. Possible values
   are:
   "exit" - Session ended due to a <exit> element
   "error" - Session ended due to an unhandled error event
   "kill" - Session ended due to ccxml.kill* event
     _________________________________________________________

    6.3.5: ccxml.loaded - CCXML Document Loaded Event

   This event is thrown once the document is parsed and ready for
   execution (document initialization occurs between the fetched and
   loaded events). The CCXML platform MUST generate this event when the
   CCXML document is first loaded, both at session startup and after
   transferring control to a new document with the <goto>. This event
   would be processed after the platform had executed the document
   initialization including executing any elements under the <ccxml>
   and before events such as connection.alerting which may have
   triggered creation of the session.

   The fields of this event are:

   Attribute Name Required Type Details
   name true string ccxml.loaded
   sessionid true string The identifier of the session on which this
   document is executing.
   parent true string The identifier of the session which issued the
   createccxml to start this document. If this document was started
   directly by the CCXML platform the value is ECMAScript undefined.
   eventid true string The unique identifier for the event. This must
   match the sendid attribute of send, if the event was generated by a
   CCXML document.
   eventsource true string The unique identifier of the event source.
   This identifies the CCXML Event I/O Processor that sent this event.
   eventsourcetype true string The name of the Event I/O Processor that
   sent this event. This must be set to ccxml as this is an event
   generated by the CCXML Session Event processor.
     _________________________________________________________

    6.3.6: ccxml.kill - CCXML kill Event

   The kill event can be used by the platform to terminate a session
   without an explicit <exit>. There are two versions of this event:
   catchable, and non-catchable.

   The ccxml.kill event can be caught, typically to perform a clean-up
   operation at the end of a session. If the event is caught the
   session will not be terminated unless the an <exit> element is
   processed. If the event is not caught the session will be terminated
   and all active connections, conferences and dialogs that are owned
   by that session will be automatically terminated by the platform.

   Unlike other events, the ccxml.kill.unconditional event is the only
   event that cannot be caught by an application; it will
   unconditionally terminate the session and all active connections,
   conferences and dialogs that are owned by that session will be
   automatically terminated by the platform.

   Note that while the normal cause of a ccxml.kill or
   ccxml.kill.unconditional event being queued to a session is that the
   platform wishes to terminate the session, it is legal for any event
   I/O processor to generate a ccxml.kill or ccxml.kill.unconditional
   event. For instance, it is legal for one CCXML session to
   unconditionally kill another session by sending a
   ccxml.kill.unconditional event using <send>. Note, however, that
   platforms may impose rules that prevent one session from arbitrarily
   killing another (to prevent malicious applications, for instance).

   The fields of this event are:

   Attribute Name Required Type Details
   name true string ccxml.kill
   sessionid true string The identifier of the session.
   reason true string A string describing the reason the platform sent
   the kill event. Content of this field is platform-specific, and is
   only for informative purposes.
   eventid true string The unique identifier for the event. This must
   match the sendid attribute of send, if the event was generated by a
   CCXML document.
   eventsource true string The unique identifier of the event source.
   This identifies the CCXML Event I/O Processor that sent this event.
   eventsourcetype true string The name of the Event I/O Processor that
   sent this event. This would be set to ccxml as this is an event
   generated by the CCXML Session Event processor.
     _________________________________________________________

    6.3.7: ccxml.created - CCXML Session Create Completion Event

   This event is generated when a <createccxml> request completes
   successfully. It is delivered to the document which issued the
   request and indicates that the new session has retrieved the
   specified initial CCXML document, parsed and has begun execution of
   it by sending the ccxml.loaded event to the new session.

   The fields of this event are:

   Attribute Name Required Type Details
   name true string ccxml.created
   sessionid true string The identifier of the newly created CCXML
   session. This must be the same identifier as was returned on the
   sessionid attribute of the createccxml request that created the
   session.
   eventid true string The unique identifier for the event. This must
   match the sendid attribute of send, if the event was generated by a
   CCXML document.
   eventsource true string The unique identifier of the event source.
   This identifies the CCXML Event I/O Processor that sent this event.
   eventsourcetype true string The name of the Event I/O Processor that
   sent this event. This must be set to ccxml as this is an event
   generated by the CCXML Session Event processor.
     _________________________________________________________

    6.3.8: error.createccxml - CCXML Session Create Failed Event

   This event is generated when a <createccxml> request fails to
   complete. It is delivered to the document which issued the request
   and indicates that the new session has not been created.

   The fields of this event are:

   Attribute Name Required Type Details
   name true string error.createccxml
   sessionid true string The identifier of the failing CCXML session.
   This is the same identifier as was returned on the sessionid
   attribute of the createccxml request that created the session.
   reason reason string A string description of the error encountered.
   Content of this field is platform-specific.
   eventid true string The unique identifier for the event. This must
   match the sendid attribute of send, if the event was generated by a
   CCXML document.
   eventsource true string The unique identifier of the event source.
   This identifies the CCXML Event I/O Processor that sent this event.
   eventsourcetype true string The name of the Event I/O Processor that
   sent this event. This must be set to ccxml as this is an event
   generated by the CCXML Session Event processor.
     _________________________________________________________

    6.3.9: error.unsupported - CCXML Unsupported Operation

   This event is generated when an operation that is not supported by
   the platform is executed.

   The fields of this event are:

   Attribute Name Required Type Details
   name true string error.unsupported
   reason true string A string description of the error encountered.
   Content of this field is platform-specific.
   eventid true string The unique identifier for the event. This must
   match the sendid attribute of send, if the event was generated by a
   CCXML document.
   eventsource true string The unique identifier of the event source.
   This identifies the Platform Event I/O Processor that sent this
   event.
   eventsourcetype true string The name of the Event I/O Processor that
   sent this event. The value is platform dependent as this is an event
   generated by the Platform Event I/O processor.
     _________________________________________________________

7: Dialogs

  7.1: Overview

   CCXML does not provide any mechanism for interacting with callers
   but relies on separate dialog environments such as VoiceXML
   [290]VOICEXML]. Whenever interaction with a caller is required, a
   CCXML session can create a separate dialog to perform that
   interaction. After the dialog interaction is complete, an
   asynchronous event is sent to the CCXML session which can use any
   results returned by the dialog environment to decide what should
   happen next.

   Dialogs initiated by CCXML sessions are not tied to any single
   dialog language or technology. Any dialog system which fulfils
   CCXML's requirements MAY be used for interaction with the caller.
   Examples of dialog systems include VoiceXML, SALT  [291]SALT ],
   traditional IVR, 3GPP MRF as well as simple media handling systems
   for fax, media playback and recording, DTMF detection,
   answer-machine detectors, etc. A CCXML platform MAY support
   interaction with several dialog systems with the selection of the
   particular technology being based on the MIME type specified when
   the dialog is initiated.

   All CCXML elements that manipulate dialogs are asynchronous with
   control returning immediately to the CCXML session after the
   operation is initiated. The CCXML session is notified when the
   dialog operation successfully completes, or fails, by an
   asynchronous event.

   A CCXML program initiates a dialog using the <dialogstart> element.
   Execution of this element connects a dialog environment to a
   connection and instructs it to start interacting with the caller.
   For some dialog environments it may take some time to initialize the
   dialog environment and thus the use of the <dialogstart> element
   alone may cause the caller to hear silence, or "dead air". To avoid
   this situation CCXML provides an ability to ready a dialog
   environment prior to connecting and starting it, this is done using
   the <dialogprepare> element. Any dialog that has been either started
   with <dialogstart>, or prepared with <dialogprepare> can be
   terminated using the <dialogterminate> element. CCXML
   implementations MUST support the <dialogprepare>, <dialogstart>, and
   <dialogterminate> elements though the exact behaviour may vary
   depending on the dialog environments supported.

   The following examples illustrate the valid use patterns for these
   three elements. Firstly the normal case of preparing a dialog,
   starting it, then optionally terminating it before normal
   completion. This example illustrates the use of <dialogprepare> to
   ready a dialog while the call is left in alerting state. When the
   alerting notification arrives the script executes a <dialogprepare>
   to prepare a dialog and associate it with the connection. When the
   dialog is prepared the script executes an <accept> to connect the
   call and then when the connection transitions to connected state, a
   <dialogstart> element is used to execute the previously prepared
   dialog.
<transition event="connection.alerting">
    <dialogprepare src="..." connectionid="event$.connectionid"/>
</transition>
<transition event="dialog.prepared">
    <accept connectionid="session.dialogs[event$.dialogid].connectionid
"/>
</transition>

<transition event="connection.connected" >
    <dialogstart prepareddialogid="event$.connection.dialogid"
                    connectionid="event$.connectionid"/>
</transition>

(optionally)
<transition event="???">
    <dialogterminate dialogid="..." />
</transition>

   The next example shows a single step dialog invocation without
   dialog preparation. In this case a connection in alerting state is
   accepted and, when the transition to connected state occurs, a
   <dialogstart> element is used to start the dialog.
<transition event="connection.alerting">
    <accept connectionid="event$.connectionid"/>
</transition>

<transition event="connection.connected">
    <dialogstart src="..." connectionid="connectionid"/>
</transition>

(optionally)
<transition event="???">
    <dialogterminate dialogid="..." />
</transition>

   This next example shows the preparation of a dialog for an outbound
   call:
<transition event="...">
    <dialogprepare src="..."> <!-- no connectionid -->
</transition>
<transition event="dialog.prepared" >
    <createcall dest="..." joinid="event$.dialogid"> <!-- use joinid --
>
</transition>
<transition event="connection.connected">
    <dialogstart prepareddialogid="event$.connection.dialogid"
                 connectionid="event$.connectionid"/>
</transition>

   The final example shows the case where a dialog which has been
   previously prepared is cancelled before a <dialogstart> has been
   issued. A dialog may be terminated when it is in the prepared state
   or while it is being prepared such as might be the case if the
   caller hangs up at some arbitrary point. In this case the
   <dialogterminate> may be executed before or after the
   dialog.prepared event is processed.
<transition event="connection.connected">>
    <dialogprepare src="..." connectionid="event$.connectionid"/>
</transition>
<transition event="connection.disconnected" >
    <dialogterminate dialogid="event$.connection.dialogid" />
</transition>

   It is possible for Dialogs to exist that are not joined to a
   Connection or a Conference. For example, this could be due to a
   Connection disconnecting, or due to the application performing an
   <unjoin/> operation.

  7.2: Elements

    7.2.1: <dialogprepare>

      7.2.1.1: Overview

   <dialogprepare> is used to get an appropriate dialog handler ready
   to process, it is used as the precursor to a <dialogstart> request.
   The element includes a URI reference to the initial document for the
   dialog. The new dialog is prepared on a separate logical execution
   thread (this MAY be a thread, process, or system depending upon
   platform implementation) and does not block the processing of
   further events by the CCXML session. The use of the <dialogprepare>
   element is entirely optional, applications may choose to simply use
   <dialogstart> without prior preparation.

   Optionally the new dialog may be associated with a connection by
   specifying the connectionid attribute, or with a conference by
   specifying the conferenceid attribute.

   When preparation of the dialog completes successfully a
   dialog.prepared event MUST be posted to the event queue of the CCXML
   session. If however the dialog cannot be prepared for any reason, an
   error.dialog.notprepared event MUST be posted. However should the
   dialog be terminated using <dialogterminate> while it is being
   prepared the platform MUST only post a dialog.exit event.

   CCXML implementations MUST support dialog preparation though the
   processing carried out as part of a <dialogprepare> request is
   dialog manager specific. In the case of a dialog manager that does
   not support preparation, the CCXML implementation MUST as a minimum,
   note the values provided in the <dialogprepare> attributes, create a
   Dialog object, and return a new unique value to the location defined
   by the dialogid attribute and throw a dialog.prepared event.

   The CCXML session selects what it believes to be the appropriate
   dialog manager based on the MIME type specified by the type
   attribute without retrieving the resource specified by the src URI.
   If, when the dialog manager retrieves the content, it finds the MIME
   type, as specified by the HTTP headers, differs from that specifed
   by the type attribute, it MUST raise an error.dialog.notprepared
   event with a reason indicating the type mismatch. The dialog manager
   MUST NOT ignore the type mismatch or render the resource as a
   different type based on the HTTP headers or on inspection of the
   document data. Refer to the W3C guidelines for client handling of
   MIME types [292]MIME-TAG] for further information.

      7.2.1.2: <dialogprepare> Attribute Details

   Name Required Attribute Constraints Type Default Value Valid Values
   Description
   src true ECMAScript Expression none a Dialog URL An ECMAScript
   expression which returns a character string identifying the URI of
   the dialog document that the dialog interpreter must prepare.
   type false ECMAScript Expression application/voicexml+xml a Valid
   MIME Type An ECMAScript expression which returns a character string
   that specifies the MIME type of the document, and as a result
   determines which dialog manager environment must actually be used.
   Values defined by the specification are:

   application/voicexml+xml
          This MIME type would request a VoiceXML interpreter instance.

   audio/wav
          This MIME type would request a dialog manager that merely
          plays wave files.

   namelist false Var List none List of ECMAScript Variable names A
   list of one or more whitespace separated CCXML variable names. These
   variables must be submitted to the web server, with the same
   qualification as used in the namelist. When an ECMAscript variable
   is submitted to the web server, its value must be first converted
   into a string before being submitted.
   If the variable is an ECMAScript Object, the mechanism by which it
   is submitted is not currently defined. Instead of submitting
   ECMAScript Objects directly, the application developer may
   explicitly submit the properties of an Object. e.g. "date.month
   date.year".
   parameters false Var List none List of ECMAScript Variable names A
   list of one or more whitespace separated CCXML variable names. These
   variables are sent to the dialog environment as a list of name/value
   pairs. Names are sent exactly as they are specified; values are
   formed by converting the referenced ECMAScript variable to string
   form (which is undefined for objects). The dialog environment
   determines how passed parameters will be handled
   dialogid false ECMAScript Left Hand Side Expression none ECMAScript
   Variable An ECMAScript left hand side expression evaluating to a
   previously defined variable. The value of the attribute must receive
   a dialog identifier value for the launched dialog interpreter
   instance.
   connectionid false Must not be used with conferenceid ECMAScript
   Expression none Connection IDs An Optional ECMAScript expression
   which returns the identifier of a connection. The specified
   connection must be associated with the dialog being prepared. If the
   attribute value is invalid an error.semantic event must be thrown.
   conferenceid false Must not be used with connectionid ECMAScript
   Expression none Conference IDs An Optional ECMAScript expression
   which returns the identifier of a conference bridge. A connection
   must be allocated for the dialog being prepared. If the attribute
   value is invalid an error.semantic event must be thrown.
   mediadirection false ECMAScript Expression both both dialogtransmit
   dialogreceive An ECMAScript expression that defines the direction of
   the media flow between the Dialog and the Connection or Conference.
   The following values must be used:

   both
          Specifies a full duplex connection where the media flows in
          both directions.

   dialogtransmit
          The dialog transmits media to the Connection or Conference
          but does not receive any media streams.

   dialogreceive
          The dialog receives media from the Connection or Conference
          but does not transmit any media streams.

   The bridge does not take place until a subsequent dialogstart is
   executed, but this attribute may be provided as guidance to the
   dialog environment for preparation. If no value is specified, the
   dialog environment must make no assumptions as to the bridging type.
   For more information about connections and bridges, refer to
   [293]Section 10 .
   maxage false ECMAScript Expression none An ECMAScript expression
   which returns a character string in CSS2 [294][2] format The
   character string returned must be interpreted as a time interval.
   This indicates that the document is willing to use content whose age
   is no greater than the specified time in seconds (cf. 'max-age' in
   HTTP 1.1 [295][RFC2616]). The document is not willing to use stale
   content, unless maxstale is also provided.
   maxstale false ECMAScript Expression none An ECMAScript expression
   which returns a character string in CSS2 [296][2] format The
   character string returned must be interpreted as a time interval.
   This indicates that the document is willing to use content that has
   exceeded its expiration time (cf. 'max-age' in HTTP 1.1
   [297][RFC2616]). If maxstale is assigned a value, then the document
   is willing to accept content that has exceeded its expiration time
   by no more than the specified number of seconds.
   enctype false Valid only when the value of the method is "post"
   ECMAScript Expression application/x-www-form-urlencoded valid media
   encoding type An ECMAScript expression which returns a character
   string that indicates the media encoding type of the submitted
   document (when the value of the method is "post"). Values defined by
   the specification are:

      [2] http://www.w3.org/TR/2007/WD-ccxml-20070119/
      [2] http://www.w3.org/TR/2007/WD-ccxml-20070119/

   application/x-www-form-urlencoded
          This indicates that the ccxml variables specified in the
          namelist must be url encoded.

   method false ECMAScript Expression get get post An ECMAScript
   expression which returns a character string that indicates the HTTP
   method to use. Values defined by the specification are:

   get
          This indicates that the "GET" method must be used by the
          dialog manager.

   post
          This indicates that the "POST" method must be used by the
          dialog manager.

   hints false ECMAScript Expression none An ECMAScript expression that
   returns an ECMAScript object The ECMAScript object returned contains
   information which may be used by the implementing platform for
   implementing the dialog operation. Note: The meaning of these hints
   is specific to the implementing platform and dialog type.

    7.2.2: <dialogstart>

      7.2.2.1: Overview

   <dialogstart> is used to start a dialog and associate the dialog
   with a connection or conference. (See [298]Section 10 for a
   discussion of connections and bridges). The element includes either
   a URI reference to the initial document for the dialog or the
   identity of a previously prepared dialog. The dialog executes on a
   separate logical execution thread (this MAY be a thread, process, or
   system depending upon platform implementation) and does not block
   the processing of further events by the CCXML session.

   If the dialog cannot be started for any reason, an
   error.dialog.notstarted event MUST be posted to the event queue of
   the CCXML session that processed the <dialogstart> request
   otherwise, a dialog.started event MUST be posted to indicate that
   the dialog has started successfully. When the dialog completes, a
   dialog.exit event MUST be posted.

   If the connectionid attribute of <dialogstart> is specified, and if
   the dialog language allows access to telephony variables such as
   ANI, DNIS and UUI, values of these variables will be propagated from
   the specified connection to the dialog application.

   If the prepareddialogid attribute is specified and any attribute
   values conflict with the values specified in the <dialogprepare>
   element this MUST result in the throwing of an
   error.dialog.notstarted event.

   Dialogs MAY only be started on connections while they are in the
   ALERTING or CONNECTED states. For connections in the ALERTING state
   media MAY not be sent or received by the connection making the
   bridge effectively full-duplex, half-duplex or silent depending on
   the underlying telephony environment and the restrictions imposed by
   it.

   The CCXML session selects the appropriate dialog manager based on
   the MIME type specified by the type attribute without retrieving the
   resource specified by the src URI. If, when the dialog manager
   retrieves the content, it finds the MIME type, as specified by the
   HTTP headers, differs from that specifed by the type attribute, it
   MUST raise an error.dialog.notstarted event with a reason indicating
   the type mismatch. The dialog manager MUST NOT ignore the type
   mismatch or render the resource as a different type based on the
   HTTP headers or on inspection of the document data. Refer to the W3C
   guidelines for client handling of MIME types [299]MIME-TAG] for
   further information.

      7.2.2.2: <dialogstart> Attribute Details

   Name Required Attribute Constraints Type Default Value Valid Values
   Description
   src false This attribute must not be specified in conjunction with
   the prepareddialogid attribute. ECMAScript Expression none a valid
   Dialog URL An ECMAScript expression which returns a character string
   identifying the URI of the dialog document that the dialog
   interpreter must load and begin execution upon startup.
   prepareddialogid false This attribute must not be specified in
   conjunction with the src, type or namelist attributes. ECMAScript
   Expression none a valid dialogid An ECMAScript expression which
   returns a dialog identifier of a dialog previously prepared by the
   execution of a dialogprepare element.
   type false This attribute must not be specified in conjunction with
   the prepareddialogid attribute. ECMAScript Expression
   application/voicexml+xml a Valid MIME Type An ECMAScript expression
   which returns a character string that specifies the MIME type of the
   document, and as a result determines which dialog manager
   environment must actually be used. Values defined by the
   specification are:

   application/voicexml+xml
          This MIME type would request a VoiceXML interpreter instance.

   audio/wav
          This MIME type would request a dialog manager that merely
          plays wave files.

   namelist false This attribute must not be specified in conjunction
   with the prepareddialogid attribute. Var List none List of
   ECMAScript Variable names A list of one or more whitespace separated
   CCXML variable names. These variables must be submitted to the web
   server, with the same qualification as used in the namelist. When an
   ECMAscript variable is submitted to the web server, its value must
   be first converted into a string before being submitted.
   If the variable is an ECMAScript Object, the mechanism by which it
   is submitted is not currently defined. Instead of submitting
   ECMAScript Objects directly, the application developer may
   explicitly submit the properties of an Object. e.g. "date.month
   date.year".
   parameters false This attribute must not be specified in conjunction
   with the prepareddialogid attribute. Var List none List of
   ECMAScript Variable names A list of one or more whitespace separated
   CCXML variable names. These variables are sent to the dialog
   environment as a list of name/value pairs. Names are sent exactly as
   they are specified; values are formed by converting the referenced
   ECMAScript variable to string form (which is undefined for objects).
   The dialog environment determines how passed parameters will be
   handled
   dialogid false ECMAScript Left Hand Side Expression none ECMAScript
   Variable An ECMAScript left hand side expression evaluating to a
   previously defined variable. The value of the attribute must receive
   a dialog identifier value for the launched dialog interpreter
   instance. This identifier may be used on future invocations of
   dialogterminate.
   connectionid false Must not be used with conferenceid. ECMAScript
   Expression none Connection IDs An Optional ECMAScript expression
   which returns the identifier of a connection. The specified
   connection must be associated with the dialog being prepared. If
   both the connectionid and the conferenceid are omitted and the
   dialog was previously prepared using a dialogprepare element with a
   connectionid or conferenceid specified, the interpreter must use the
   id as specified on the dialogprepare element.
   If neither the connectionid or conferenceid is specified and the
   dialog had not previously been prepared, the interpreter must use
   the id indicated in the current event being processed. For more
   information about connections and bridges, refer to [300]Section 10
   . If both connectionid and conferenceid are specified, an
   error.fetch event must be thrown. If the attribute value is invalid
   an error.semantic event must be thrown.
   conferenceid false Must not be used with connectionid. ECMAScript
   Expression none Conference IDs An Optional ECMAScript expression
   which returns the identifier of a conference bridge. If both the
   connectionid and the conferenceid are omitted and the dialog was
   previously prepared using a dialogprepare element with a
   connectionid or conferenceid specified, the interpreter must use the
   id as specified on the dialogprepare element.
   If neither the connectionid or conferenceid is specified and the
   dialog had not previously been prepared, the interpreter must use
   the id indicated in the current event being processed. For more
   information about connections and bridges, refer to [301]Section 10
   . If both connectionid and conferenceid are specified, an
   error.fetch event must be thrown. If the attribute value is invalid
   an error.semantic event must be thrown.
   mediadirection false If used in conjunction with prepareddialogid ,
   the bridge type must match that used on the previous dialogprepare
   element. ECMAScript Expression both both dialogtransmit
   dialogreceive An ECMAScript expression that defines the direction of
   the media flow between the Dialog and the Connection or Conference.
   The following values must be used:

   both
          Specifies a full duplex connection where the media flows in
          both directions.

   dialogtransmit
          The dialog transmits media to the Connection or Conference
          but does not receive any media streams.

   dialogreceive
          The dialog receives media from the Connection or Conference
          but does not transmit any media streams.

   If both the mediadirection and the prepareddialogid are specified
   and the bridge type specified by the mediadirection attribute does
   not match that used on the previous dialogprepare element, an
   error.dialog.notstarted event must be raised. If no value for the
   mediadirection attribute was specified on the previous dialogprepare
   element, any mediadirection type option may be specified.
   maxage false ECMAScript Expression none An ECMAScript expression
   which returns a character string in CSS2 [302][2] format The
   character string returned must be interpreted as a time interval.
   This indicates that the document is willing to use content whose age
   is no greater than the specified time in seconds (cf. 'max-age' in
   HTTP 1.1 [303][RFC2616]). The document is not willing to use stale
   content, unless maxstale is also provided.
   maxstale false ECMAScript Expression none An ECMAScript expression
   which returns a character string in CSS2 [304][2] format The
   character string returned must be interpreted as a time interval.
   This indicates that the document is willing to use content that has
   exceeded its expiration time (cf. 'max-age' in HTTP 1.1
   [305][RFC2616]). If maxstale is assigned a value, then the document
   is willing to accept content that has exceeded its expiration time
   by no more than the specified number of seconds.
   enctype false Valid only when the value of the method is "post"
   ECMAScript Expression application/x-www-form-urlencoded valid media
   encoding type An ECMAScript expression which returns a character
   string that indicates the media encoding type of the submitted
   document (when the value of the method is "post"). Values defined by
   the specification are:

      [2] http://www.w3.org/TR/2007/WD-ccxml-20070119/
      [2] http://www.w3.org/TR/2007/WD-ccxml-20070119/

   application/x-www-form-urlencoded
          This indicates that the ccxml variables specified in the
          namelist must be url encoded.

   method false ECMAScript Expression get get post An ECMAScript
   expression which returns a character string that indicates the HTTP
   method to use. Values defined by the specification are:

   get
          This indicates that the "GET" method must be used by the
          dialog manager.

   post
          This indicates that the "POST" method must be used by the
          dialog manager.

   hints false ECMAScript Expression none An ECMAScript expression that
   returns an ECMAScript object The ECMAScript object returned contains
   information which may be used by the implementing platform for
   implementing the dialog operation. Note: The meaning of these hints
   is specific to the implementing platform and dialog type.

    7.2.3: <dialogterminate>

      7.2.3.1: Overview

   A CCXML document may decide that it wants to terminate a currently
   executing dialog, to throw away a previously prepared dialog, or to
   terminate the preparation of a dialog. This is accomplished using
   the <dialogterminate> element. When the CCXML interpreter encounters
   a <dialogterminate> element, it MUST send a terminate request to the
   specified dialog.

   A dialog terminated due to the processing of a <dialogterminate>
   element MAY still return data to the CCXML application using a
   dialog.exit event if the value of the immediate attribute is false
   or unspecified. The details of the data returned are dialog
   environment specific.

   If the immediate attribute is set to true the dialog MUST NOT return
   data to the CCXML application and the CCXML interpreter MUST post a
   dialog.exit event immediately.

   The platform MUST implicitly tear down any existing bridges to the
   dialog and send a conference.unjoined to the CCXML document once the
   media paths have been freed.

      7.2.3.2: <dialogterminate> Attribute Details

   Name Required Attribute Constraints Type Default Value Valid Values
   Description
   dialogid true ECMAScript Expression none valid dialog ID An
   ECMAScript expression which returns a character string identifying
   the dialog. This dialogid was returned in the variable identified by
   the dialogid attribute of previous dialogstart or dialogprepare
   request or the value in a dialog.started or dialog.prepared event.
   immediate false ECMAScript Expression false true false An ECMAScript
   expression which returns a character string, that identifies the
   termination style of the dialog. Valid values are:

   true
          This indicates that the dialog must be terminated
          immediately.

   false
          This indicates that the dialog must be terminated in a normal
          fashion.

   hints false ECMAScript Expression none An ECMAScript expression that
   returns an ECMAScript object The ECMAScript object returned contains
   information which may be used by the implementing platform for
   implementing the dialog operation. Note: The meaning of these hints
   is specific to the implementing platform and dialog type.

  7.3: Events

    7.3.1: Overview

   The majority of communication between CCXML interpreter sessions and
   dialogs is by way of events. Dialog environments post events to the
   CCXML interpreter event queue and a CCXML application MAY send an
   event to a dialog. How this is handled on the dialog side is dialog
   manager and CCXML interpreter dependent. On the CCXML side it is
   done by using <send> and passing in the dialogid that was received
   as a result of processing a <dialogstart> or a <dialogprepare>.

   The following are the CCXML events related to dialogs:

    7.3.2: dialog.started

   The dialog.started event MUST be thrown when a dialog is
   successfully started. The fields available in the event are:

   Attribute Name Required Type Details
   name true string dialog.started
   dialogid true string The ID of the dialog.
   dialog true ECMAScript Object An ECMAScript object reference to the
   dialog object identified by the dialogid property of this event.
   connectionid false string The identifier of the connection to which
   the dialog connection is bridged (usually the connectionid that was
   specified in the dialogstart or dialogprepare).
   If the dialog is bridged to a conference the value must be
   undefined.
   conferenceid false string The identifier of the conference to which
   the dialog connection is bridged (usually the conferenceid that was
   specified in the dialogstart or dialogprepare).
   If the dialog is bridged to a connection the value must be
   undefined.
   eventid true string The unique identifier for the event. This must
   match the sendid attribute of send, if the event was generated by a
   CCXML document.
   eventsource true string The unique identifier of the event source.
   This identifies the DIALOG Event I/O Processor that sent this event.
   eventsourcetype true string The name of the Event I/O Processor that
   sent this event. This must be set to dialog as this is an event
   generated by the Dialog Session Event processor.
     _________________________________________________________

    7.3.3: dialog.exit

   The dialog.exit event MUST be thrown when a dialog terminates either
   normally or following a <dialogterminate> request. Termination of a
   dialog always results in a single dialog.exit event; if normal
   dialog termination and a <dialogterminate> occur simultaneously, the
   dialog.exit event will reflect the condition that the platform
   processes first. For example, if a dialog.exit event is thrown based
   on normal termination, and the platform subsequently processes a
   <dialogterminate> request made by the application, it will discard
   the <dialogterminate> and will not generate a second dialog.exit
   event. The fields available in the event are:

   Attribute Name Required Type Details
   name true string dialog.exit
   dialogid true string The ID of the dialog.
   dialog true ECMAScript Object An ECMAScript object reference to the
   dialog object identified by the dialogid property of this event.
   connectionid false string The identifier of the connection to which
   the dialog connection is bridged (usually the connectionid that was
   specified in the dialogstart or dialogprepare).
   If the dialog is bridged to a conference the value must be
   undefined.
   conferenceid false string The identifier of the conference to which
   the dialog connection is bridged (usually the conferenceid that was
   specified in the dialogstart or dialogprepare).
   If the dialog is bridged to a connection the value must be
   undefined.
   false string valued array
   values.* false ECMAScript Object Return values from the dialog. In
   VoiceXML this would be the values of each of the objects listed in
   the exit element's namelist.
   eventid true string The unique identifier for the event. This must
   match the sendid attribute of send, if the event was generated by a
   CCXML document.
   eventsource true string The unique identifier of the event source.
   This identifies the DIALOG Event I/O Processor that sent this event.
   eventsourcetype true string The name of the Event I/O Processor that
   sent this event. This must be set to dialog as this is an event
   generated by the Dialog Session Event processor.
     _________________________________________________________

    7.3.4: dialog.disconnect

   The dialog.disconnect event represents a request by a dialog to
   disconnect the Connection or Conference with which it is presently
   associated. The actual handling of this event is determined entirely
   by the running CCXML application, which may disconnect the
   associated Connection, detach the dialog from the
   Connection/Conference, or elect to ignore the dialog.disconnect
   event altogether. The fields available in the event are:

   Attribute Name Required Type Details
   name true string dialog.disconnect
   dialogid true string The ID of the dialog.
   dialog true ECMAScript Object An ECMAScript object reference to the
   dialog object identified by the dialogid property of this event.
   connectionid false string The identifier of the connection to which
   the dialog connection is bridged (usually the connectionid that was
   specified in the dialogstart or dialogprepare).
   If the dialog is bridged to a conference the value must be
   undefined.
   conferenceid false string The identifier of the conference to which
   the dialog connection is bridged (usually the conferenceid that was
   specified in the dialogstart or dialogprepare).
   If the dialog is bridged to a connection the value must be
   undefined.
   false string valued array
   values.* false ECMAScript Object Return values from the dialog. In
   VoiceXML this would be the values of each of the objects listed in
   the dialog element's namelist.
   eventid true string The unique identifier for the event. This must
   match the sendid attribute of send, if the event was generated by a
   CCXML document.
   eventsource true string The unique identifier of the event source.
   This identifies the DIALOG Event I/O Processor that sent this event.
   eventsourcetype true string The name of the Event I/O Processor that
   sent this event. This must be set to dialog as this is an event
   generated by the Dialog Session Event processor.
     _________________________________________________________

    7.3.5: dialog.transfer

   The dialog.transfer event represents a request by a dialog to
   transfer the Connection or Conference with which it is presently
   associated to a new destination. The actual handling of this event
   is determined entirely by the running CCXML application, which may
   perform a <redirect> on the associated Connection, use <createcall>
   and <join> to establish a bridged transfer, handle the transfer
   request in some other way, or elect to ignore the dialog.transfer
   event altogether. The properties of the dialog.transfer event
   reflect the information dialog environments are most likely to
   supply when requesting a transfer, but are up to the running CCXML
   application to interpret. The fields available in the event are:

   Attribute Name Required Type Details
   name true string dialog.transfer
   dialogid true string The ID of the dialog.
   dialog true ECMAScript Object An ECMAScript object reference to the
   dialog object identified by the dialogid property of this event.
   connectionid false string The identifier of the connection to which
   the dialog connection is bridged (usually the connectionid that was
   specified in the dialogstart or dialogprepare).
   If the dialog is bridged to a conference the value must be
   undefined.
   conferenceid false string The identifier of the conference to which
   the dialog connection is bridged (usually the conferenceid that was
   specified in the dialogstart or dialogprepare).
   If the dialog is bridged to a connection the value must be
   undefined.
   type true string A string value specifying the transfer type.
   URI true a valid URI A URI describing the destination to which this
   call must be transferred. The format of this information is protocol
   and platform specific but might consist of a telephone URI
   [306]RFC2806 or a SIP URI [307]RFC3261 .
   false string valued array
   values.* false ECMAScript Object Properties returned from the dialog
   processor relating to the dialogs transfer request.
   maxtime true string A string in CSS2 format that specifies the
   maximum amount of time the transfer may stay connected. If the
   amount of time is unlimited the value must be 0s.
   connecttimeout true string A string in CSS2 format that specifies
   the maximum amount of time to spend while attempting to connect the
   call.
   aai false string A string of application-to-application information
   to be passed to the destination party when establishing the
   transfer.
   eventid true string The unique identifier for the event. This must
   match the sendid attribute of send, if the event was generated by a
   CCXML document.
   eventsource true string The unique identifier of the event source.
   This identifies the DIALOG Event I/O Processor that sent this event.
   eventsourcetype true string The name of the Event I/O Processor that
   sent this event. This must be set to dialog as this is an event
   generated by the Dialog Session Event processor.
     _________________________________________________________

    7.3.6: dialog.terminatetransfer

   The dialog.terminatetransfer event represents a request by a dialog
   to terminate an ongoing transfer for example due to a "hotword"
   recognition. The actual handling of this event is determined
   entirely by the running CCXML application, which may terminate the
   outgoing call leg and return the media stream of the original call
   to the dialog using the <join> element, handle the terminate
   transfer request in some other way, or elect to ignore the
   dialog.terminatetransfer event altogether. The properties of the
   dialog.terminatetransfer event reflect the information dialog
   environments are most likely to supply when terminating a transfer,
   but are up to the running CCXML application to interpret. The fields
   available in the event are:

   Attribute Name Required Type Details
   name true string dialog.terminatetransfer
   dialogid true string The ID of the dialog.
   dialog true ECMAScript Object An ECMAScript object reference to the
   dialog object identified by the dialogid property of this event.
   connectionid false string The identifier of the connection to which
   the dialog connection is bridged (usually the connectionid that was
   specified in the dialogstart or dialogprepare).
   If the dialog is bridged to a conference the value must be
   undefined.
   conferenceid false string The identifier of the conference to which
   the dialog connection is bridged (usually the conferenceid that was
   specified in the dialogstart or dialogprepare).
   If the dialog is bridged to a connection the value must be
   undefined.
   reason true string A description of the reason the dialog wants the
   transfer to be terminated. Content of this field is
   platform-specific.
   eventid true string The unique identifier for the event. This must
   match the sendid attribute of send, if the event was generated by a
   CCXML document.
   eventsource true string The unique identifier of the event source.
   This identifies the DIALOG Event I/O Processor that sent this event.
   eventsourcetype true string The name of the Event I/O Processor that
   sent this event. This must be set to dialog as this is an event
   generated by the Dialog Session Event processor.
     _________________________________________________________

    7.3.7: error.dialog

   The error.dialog event MUST be thrown when there was an unspecified
   error with the dialog (for example the dialog server crashed). The
   fields available in the event are:

   The platform MUST implicitly tear down any existing bridges to the
   dialog and send a conference.unjoined to the CCXML document once the
   media paths have been freed.

   Attribute Name Required Type Details
   name true string error.dialog
   dialogid true string The ID of the dialog.
   dialog true ECMAScript Object An ECMAScript object reference to the
   dialog object identified by the dialogid property of this event.
   connectionid false string The identifier of the connection to which
   the dialog was connected to (usually the connectionid that was
   specified in the dialogstart or dialogprepare).
   If the dialog was being connected to a conference the value must be
   undefined.
   conferenceid false string The identifier of the conference to which
   the dialog was connected to (usually the conferenceid that was
   specified in the dialogstart or dialogprepare).
   If the dialog was being connected to a connection the value must be
   undefined.
   reason true string A description of the reason the dialog had an
   error. Content of this field is platform-specific.
   eventid true string The unique identifier for the event. This must
   match the sendid attribute of send, if the event was generated by a
   CCXML document.
   eventsource true string The unique identifier of the event source.
   This identifies the DIALOG Event I/O Processor that sent this event.
   eventsourcetype true string The name of the Event I/O Processor that
   sent this event. This must be set to dialog as this is an event
   generated by the Dialog Session Event processor.
     _________________________________________________________

    7.3.8: error.dialog.notstarted

   The error.dialog.notstarted event MUST be thrown when the processing
   of a <dialogstart> element fails because the dialog cannot be
   started for some reason. The fields available in the event are:

   Attribute Name Required Type Details
   name true string error.dialog.notstarted
   dialogid true string The ID of the dialog.
   dialog true ECMAScript Object An ECMAScript object reference to the
   dialog object identified by the dialogid property of this event.
   connectionid false string The identifier of the connection to which
   the dialog connection could not be started (usually the connectionid
   that was specified in the dialogstart or dialogprepare).
   If the dialog was being connected to a conference the value must be
   undefined.
   conferenceid false string The identifier of the conference to which
   the dialog connection could not be started (usually the conferenceid
   that was specified in the dialogstart or dialogprepare).
   If the dialog was being connected to a connection the value must be
   undefined.
   reason true string A description of the reason the dialog could not
   be started. Content of this field is platform-specific.
   eventid true string The unique identifier for the event. This must
   match the sendid attribute of send, if the event was generated by a
   CCXML document.
   eventsource true string The unique identifier of the event source.
   This identifies the DIALOG Event I/O Processor that sent this event.
   eventsourcetype true string The name of the Event I/O Processor that
   sent this event. This must be set to dialog as this is an event
   generated by the Dialog Session Event processor.
     _________________________________________________________

7.3.9: blank

   This section is intentionally left blank.

    7.3.10: dialog.user.*

   The dialog.user.* (where * is the name of the user defined event)
   MUST be thrown when a dialog sends a user/application-defined event.
   The fields available in the event are:

   Attribute Name Required Type Details
   name true string dialog.user.* (where * is the name of the user
   defined event)
   dialogid true string The ID of the dialog.
   dialog true ECMAScript Object An ECMAScript object reference to the
   dialog object identified by the dialogid property of this event.
   connectionid false string The identifier of the connection to which
   the dialog connection is bridged (usually the connectionid that was
   specified in the dialogstart or dialogprepare).
   If the dialog is bridged to a conference the value must be
   undefined.
   conferenceid false string The identifier of the conference to which
   the dialog connection is bridged (usually the conferenceid that was
   specified in the dialogstart or dialogprepare).
   If the dialog is bridged to a connection the value must be
   undefined.
   false string valued array
   values.* false ECMAScript Object Return values from the dialog for
   the user event.
   eventid true string The unique identifier for the event. This must
   match the sendid attribute of send, if the event was generated by a
   CCXML document.
   eventsource true string The unique identifier of the event source.
   This identifies the DIALOG Event I/O Processor that sent this event.
   eventsourcetype true string The name of the Event I/O Processor that
   sent this event. This must be set to dialog as this is an event
   generated by the Dialog Session Event processor.
     _________________________________________________________

    7.3.11: dialog.prepared

   The dialog.prepared event MUST be thrown when a dialog has been
   successfully prepared following the execution of a <dialogprepare>
   element. The fields available in the event are:

   Attribute Name Required Type Details
   name true string dialog.prepared
   dialogid true string The ID of the dialog.
   dialog true ECMAScript Object An ECMAScript object reference to the
   dialog object identified by the dialogid property of this event.
   connectionid false string The identifier of the connection to which
   the dialog connection is prepared (usually the connectionid that was
   specified in the dialogprepare).
   If the dialog was prepared without a connection, the value must be
   undefined.
   conferenceid false string The identifier of the conference to which
   the dialog connection is prepared (usually the conferenceid that was
   specified in the dialogprepare).
   If the dialog was prepared without a conferece, the value must be
   undefined.
   eventid true string The unique identifier for the event. This must
   match the sendid attribute of send, if the event was generated by a
   CCXML document.
   eventsource true string The unique identifier of the event source.
   This identifies the DIALOG Event I/O Processor that sent this event.
   eventsourcetype true string The name of the Event I/O Processor that
   sent this event. This must be set to dialog as this is an event
   generated by the Dialog Session Event processor.
     _________________________________________________________

    7.3.12: error.dialog.notprepared

   The error.dialog.notprepared event MUST be thrown when the
   processing of a <dialogprepare> element fails. The fields available
   in the event are:

   Attribute Name Required Type Details
   name true string error.dialog.notprepared
   dialogid true string The ID of the dialog.
   dialog true ECMAScript Object An ECMAScript object reference to the
   dialog object identified by the dialogid property of this event.
   reason true string A description of the reason the dialog could not
   be prepared. Content of this field is platform-specific.
   connectionid false string The identifier of the connection to which
   the dialog connection was attempting to be prepared (usually the
   connectionid that was specified in the dialogprepare).
   If the dialog was prepared without a connection, the value must be
   undefined.
   conferenceid false string The identifier of the conference to which
   the dialog connection was attempting to be prepared (usually the
   conferenceid that was specified in the dialogprepare).
   If the dialog was prepared without a conferece, the value must be
   undefined.
   eventid true string The unique identifier for the event. This must
   match the sendid attribute of send, if the event was generated by a
   CCXML document.
   eventsource true string The unique identifier of the event source.
   This identifies the DIALOG Event I/O Processor that sent this event.
   eventsourcetype true string The name of the Event I/O Processor that
   sent this event. This must be set to dialog as this is an event
   generated by the Dialog Session Event processor.
     _________________________________________________________

  7.4: Dialog Object Properties

   An instance of the Dialog object is associated with each dialog
   created by <dialogstart> or <dialogprepare> and referenced in the
   session.dialogs associative array.

   The Dialog Object is an extension of the [308]Media Endpoint Object
   as defined in section 10.4.3.

   Dialog Properties Required Definitions
   dialogid true This property is the ECMAScript string value of the
   Dialog Identifier, which uniquely identifies each instance of the
   Dialog class.
   connectionid false Identifies the connection that is driving a media
   stream to the dialog. If the media stream to the dialog is not being
   driven by a connection, then this property must be undefined.
   Note: connectionid and conferenceid properties are mutually
   exclusive.
   conferenceid false Identifies the conference that is driving a media
   stream to the dialog. If the media stream to the dialog is not being
   driven by a conference, then