<!--
VoiceXML 2.0 DTD (20020327)

Copyright 1998-2002 W3C (MIT, INRIA, Keio), All Rights Reserved.

Permission to use, copy, modify and distribute the VoiceXML DTD and
its accompanying documentation for any purpose and without fee is
hereby granted in perpetuity, provided that the above copyright
notice and this paragraph appear in all copies.

The copyright holders make no representation about the suitability
of the DTD for any purpose. It is provided "as is" without expressed
or implied warranty.
-->

<!ENTITY % custom-elements   "nuance:send">

<!ENTITY % bargeintype   "( speech | hotword )">

<!ENTITY % boolean 	"(true|false)">

<!ENTITY % content.type "CDATA">

<!ENTITY % duration "CDATA">

<!ENTITY % event.handler "catch | help | noinput | nomatch | error">

<!ENTITY % event.name "NMTOKEN">

<!ENTITY % event.names "NMTOKENS">

<!-- addition of enumerate and value elements as 'allowed-within-sentence'
audio elements.  Note that for the VWS parser, this entity must be declared
before it is reference within the entity below. -->
<!ENTITY % audio "#PCDATA | audio | enumerate | value">

<!-- <debug> is a deprecated version of the <log> tag. -->
<!-- definitions adapted from SSML 1.0 DTD -->
<!-- These prompt playback entities are defined here because they are needed
    for defining executable content -->
<!ENTITY % structure "paragraph | p | sentence | s">

<!ENTITY % sentence-elements "break | emphasis | mark | phoneme | prosody |
say-as | voice | sub">

<!ENTITY % allowed-within-sentence " %audio; | %sentence-elements; ">

<!ENTITY % executable.content "%allowed-within-sentence; | assign | clear | %custom-elements; | disconnect | exit
| goto | if | log | prompt | reprompt | return | script | %structure; | submit | throw | var | debug">

<!ENTITY % expression "CDATA">

<!ENTITY % variable.name "NMTOKEN">

<!ENTITY % variable.names "CDATA">

<!ENTITY % integer "CDATA">

<!ENTITY % item.attrs "name		%variable.name;	#IMPLIED
    cond		%expression;	#IMPLIED
    expr		%expression;	#IMPLIED ">

<!ENTITY % uri "CDATA">

<!ENTITY % cache.attrs "fetchhint	(prefetch|safe)	#IMPLIED
    fetchtimeout	%duration;	#IMPLIED
    maxage	%integer;	#IMPLIED
    maxstale	%integer;	#IMPLIED">

<!ENTITY % next.attrs "next		%uri;		#IMPLIED
    expr		%expression;	#IMPLIED ">

<!ENTITY % submit.attrs "method		(get|post)	'get'
    enctype		%content.type;	'application/x-www-form-urlencoded'
    namelist	%variable.names;	#IMPLIED">

<!ENTITY % throw.attrs "event      %event.name;    #IMPLIED
    eventexpr   %expression;    #IMPLIED
    message     CDATA       #IMPLIED
    messageexpr %expression;    #IMPLIED">

<!ENTITY % variable 	"block | field | var">


<!--================================= Root ================================-->
<!ELEMENT vxml (%event.handler; | form | link | menu | meta |
property | script | var)*>
<!ENTITY % two-zero 	"(2.0)">
<!ATTLIST vxml
    application	%uri;		#IMPLIED
    base		%uri;		#IMPLIED
    xml:lang    NMTOKENS     #IMPLIED
    xmlns       CDATA       #FIXED "http://www.w3.org/2001/vxml"
    xmlns:nuance CDATA       #FIXED "http://www.nuance.com"
    xsi:schemaLocation CDATA #IMPLIED
    version		%two-zero;     #REQUIRED
>

<!ELEMENT meta		EMPTY>
<!ATTLIST meta
    name		NMTOKEN		#IMPLIED
    content		CDATA		#REQUIRED
    http-equiv	NMTOKEN		#IMPLIED
>


<!--================================ Prompts ==============================-->
<!-- Prompt is modelled on SSML 1.0 DTD speak element:
- addition of 'bargein', 'bargeintype', 'cond', 'count' and 'timeout' attributes
- removal of xmlns, xmlns:xsi, and xsi:schemaLocation attributes
- version attribute fixed as "1.0"
-->
<!ELEMENT prompt (%allowed-within-sentence; | %structure;)*>
<!ATTLIST prompt
    bargein		%boolean;	#IMPLIED
    bargeintype %bargeintype;   #IMPLIED
    cond		%expression;	#IMPLIED
    count		%integer;	#IMPLIED
    xml:lang    NMTOKENS     #IMPLIED
    timeout		%duration;	#IMPLIED
    version CDATA #FIXED "1.0"
>

<!ELEMENT enumerate (%allowed-within-sentence; | %structure;)*>

<!ELEMENT reprompt	EMPTY>


<!--================================= Dialogs =============================-->
<!ENTITY % input "grammar">

<!ENTITY % scope 	"(document | dialog)">

<!-- Voiceprint is a Nuance extension for speaker verification and identification. -->
<!ELEMENT form (%input; | %event.handler; | filled | initial | object |
link | property | record | script | subdialog | transfer | %variable; | nuance:voiceprint)*>
<!ATTLIST form
    id		ID		#IMPLIED
    scope		%scope;		"dialog"
>

<!ENTITY % accept.attrs "accept     (exact | approximate)   'exact'">

<!-- script in the menu is a Nuance extension. -->
<!ELEMENT menu (%audio; | choice | %event.handler; | prompt | property | script)*>
<!ATTLIST menu
    id		ID		#IMPLIED
    scope		%scope;		"dialog"
    %accept.attrs;
    dtmf		%boolean;	"false"
>

<!ELEMENT choice (%allowed-within-sentence; | %structure; | grammar)*>
<!ATTLIST choice
    %cache.attrs;
    %accept.attrs;
    dtmf		CDATA		#IMPLIED
    %throw.attrs;
    fetchaudio	%uri;		#IMPLIED
    %next.attrs;
>


<!--================================ Audio Output ==============================-->
<!-- definitions adapted from SSML 1.0 DTD -->

<!ELEMENT paragraph (%allowed-within-sentence; | sentence | s)*>
<!ATTLIST paragraph
    xml:lang    NMTOKENS     #IMPLIED
>

<!ELEMENT sentence (%allowed-within-sentence;)*>
<!ATTLIST sentence
    xml:lang    NMTOKENS     #IMPLIED
>

<!ELEMENT p (%allowed-within-sentence; | sentence | s)*>
<!ATTLIST p
    xml:lang        NMTOKENS         #IMPLIED
>

<!ELEMENT s (%allowed-within-sentence;)*>
<!ATTLIST s
        xml:lang        NMTOKENS         #IMPLIED
>

<!ELEMENT voice (%allowed-within-sentence; | %structure;)*>
<!ATTLIST voice
     xml:lang        NMTOKENS         #IMPLIED
     gender   (male | female | neutral)              #IMPLIED
     age      %integer;                              #IMPLIED
     variant  %integer;                              #IMPLIED
     name     CDATA                                  #IMPLIED
>

<!ELEMENT prosody (%allowed-within-sentence; | %structure;)*>
<!ATTLIST prosody
     pitch      CDATA  #IMPLIED
     contour    CDATA  #IMPLIED
     range      CDATA  #IMPLIED
     rate       CDATA  #IMPLIED
     duration   %duration;  #IMPLIED
     volume     CDATA  #IMPLIED
>

<!-- Changes to SSML 1.0 DTD audio element:
- addition of 'expr' and caching attributes
-->
<!-- offsetexpr is a Nuance extension that specifies where in the audio to start playing. -->
<!ELEMENT audio (%allowed-within-sentence; | %structure;)*>
<!ATTLIST audio
    src		%uri;		#IMPLIED
    expr		%expression;		#IMPLIED
    %cache.attrs;
    offsetexpr  %expression;    #IMPLIED
>

<!ELEMENT emphasis (%allowed-within-sentence;)*>
<!ATTLIST emphasis
     level      (strong | moderate | none | reduced)  "moderate"
>

<!-- Changes to SSML 1.0 DTD say-as element:
- addition of vxml builtins to type
- allows value element as child
-->
<!-- As a Nuance extension, the type attribute is not constrained by the DTD. -->
<!ELEMENT say-as (#PCDATA | value )*>
<!ATTLIST say-as
     type   CDATA            #REQUIRED
>

<!ELEMENT sub (#PCDATA)>
<!ATTLIST sub
    alias CDATA #REQUIRED
>

<!ELEMENT phoneme (#PCDATA)>
<!ATTLIST phoneme
     ph        CDATA   #REQUIRED
     alphabet  CDATA   "ipa"
>

<!ELEMENT break EMPTY>

<!-- In order to detect the case where no attribute is specified on break,
     Nuance specifies the size as #IMPLIED rather than the 'medium' default. -->
<!ATTLIST break
     size      (large | medium | small | none)  #IMPLIED
     time      %duration;                 #IMPLIED
>

<!ELEMENT mark (%allowed-within-sentence; | %structure;)*>
<!ATTLIST mark
     name      ID   #REQUIRED
>

<!--================================ Fields ===============================-->
<!ELEMENT field (%audio; | %event.handler; | filled | %input; | link |
option | prompt | property)*>
<!ATTLIST field
    %item.attrs;
    type		CDATA		#IMPLIED
    slot		NMTOKEN		#IMPLIED
    modal		%boolean;	"false"
>

<!-- <option> is more powerful with optional <grammar>s and SSML markup. -->
<!ELEMENT option	(%allowed-within-sentence; | %structure; | grammar)*>

<!ATTLIST option
    %accept.attrs;
    dtmf		CDATA		#IMPLIED
    value		CDATA		#IMPLIED
>

<!ELEMENT var		EMPTY>
<!ATTLIST var
    name		%variable.name;	#REQUIRED
    expr		%expression;	#IMPLIED
>

<!ELEMENT initial	(%audio; | %event.handler; | link | prompt | property)*>
<!ATTLIST initial
    %item.attrs;
>

<!ELEMENT block	(%executable.content;)*>
<!ATTLIST block
    %item.attrs;
>

<!ELEMENT assign	EMPTY>
<!ATTLIST assign
    name		%variable.name;	#REQUIRED
    expr		%expression;	#REQUIRED
>

<!ELEMENT clear	EMPTY>
<!ATTLIST clear
    namelist	%variable.names;	#IMPLIED
>

<!ELEMENT value	EMPTY>
<!ATTLIST value
    expr		%expression;	#REQUIRED
>


<!--================================== Events =============================-->
<!ENTITY % event.handler.attrs "count		%integer;	#IMPLIED
    cond		%expression;	#IMPLIED">

<!ELEMENT catch	(%executable.content;)*>
<!ATTLIST catch
    event		%event.names;	#IMPLIED
    %event.handler.attrs;
>

<!ELEMENT error	(%executable.content;)*>
<!ATTLIST error
    %event.handler.attrs;
>

<!ELEMENT help		(%executable.content;)*>
<!ATTLIST help
    %event.handler.attrs;
>

<!ELEMENT link		(grammar)*>
<!ATTLIST link
    %cache.attrs;
    %next.attrs;
    fetchaudio	%uri;		#IMPLIED
    dtmf		CDATA		#IMPLIED
    %throw.attrs;
>

<!ELEMENT noinput	(%executable.content;)*>
<!ATTLIST noinput
    %event.handler.attrs;
>

<!ELEMENT nomatch	(%executable.content;)*>
<!ATTLIST nomatch
    %event.handler.attrs;
>

<!ELEMENT throw	EMPTY>
<!ATTLIST throw
    %throw.attrs;
>


<!--============================= Grammar Input =============================-->
<!-- definitions adapted from SRGS 1.0 DTD -->
<!ENTITY % rule-expansion "#PCDATA | token | ruleref
                              | item | one-of | tag ">

<!-- New GRXML Spec - Added lang-list - Removed xml:lang -->
<!ELEMENT ruleref EMPTY>
<!ATTLIST ruleref
     uri %uri; #IMPLIED
     type CDATA #IMPLIED
     special (NULL | VOID | GARBAGE) #IMPLIED
     lang-list NMTOKENS #IMPLIED
>

<!-- New GRXML Spec - Added lang-list - Removed xml:lang -->
<!ELEMENT token (#PCDATA)>
<!ATTLIST token
     lang-list NMTOKENS #IMPLIED
>

<!ELEMENT tag (#PCDATA)>

<!-- New GRXML Spec - Added lang-list - Removed xml:lang -->
<!ELEMENT one-of (item)+>
<!ATTLIST one-of
     lang-list NMTOKENS #IMPLIED
>

<!-- New GRXML Spec - Removed tag, xml:lang -->
<!ELEMENT item (%rule-expansion;)*>
<!ATTLIST item
     repeat NMTOKEN #IMPLIED
     repeat-prob NMTOKEN #IMPLIED
     weight NMTOKEN #IMPLIED
>

<!ELEMENT rule (%rule-expansion; | example)*>
<!ATTLIST rule
    id ID #REQUIRED
    scope (private | public) "private"
>

<!ELEMENT example (#PCDATA)>

<!--
     Nuance-extension: <grammar> also permits <nuance:redef> children, which
     can be used to define external grammars.  The <nuance:nbest> tag allows JavaScript
     "nbest" processing.
-->
<!ELEMENT grammar	( #PCDATA | rule | nuance:redef | nuance:nbest )*>
<!ATTLIST grammar
    scope		%scope;		#IMPLIED
    src		%uri;		    #IMPLIED
    type		CDATA		#IMPLIED
    weight		CDATA		#IMPLIED
    %cache.attrs;
    tag-format CDATA        "Nuance"
    version     CDATA       "1.0"
    xml:lang    NMTOKENS		#IMPLIED
    root		IDREF		#IMPLIED
    mode        (voice | dtmf)  "voice"
    expr		CDATA		#IMPLIED
>

<!-- an <redef> element describes an external grammar through a src,
     type and name of the grammar to be resolved by this external
     grammar -->
<!ELEMENT nuance:redef 	EMPTY>
<!ATTLIST nuance:redef
    src                 %uri;		#IMPLIED
    expr                 %uri;		#IMPLIED
    name		CDATA           #REQUIRED
>


<!--============================= Audio Input =============================-->
<!-- dest and destexpr are a Nuance extension that specify the destination uri
     where the recorded audio should be http posted. -->
<!ELEMENT record (%audio; | %event.handler; | filled | grammar | prompt | property)*>
<!ATTLIST record
    %item.attrs;
    type		CDATA		#IMPLIED
    beep		%boolean;	"false"
    maxtime		%duration;	#IMPLIED
    modal		%boolean;	"true"
    finalsilence	%duration;	#IMPLIED
    dtmfterm		%boolean;	"true"
    dest		%uri;		#IMPLIED
    destexpr		%expression;	#IMPLIED
>


<!--============================ Call Control ============================-->
<!ELEMENT disconnect	EMPTY>

<!-- devices is a Nuance extension used in the transfer tag. -->
<!ENTITY % devices "NMTOKENS">

<!-- type is a Nuance extension deprecating the bridge attribute and
     allowing the specification of a third type: conditional.  A conditional
     transfer will disconnect the system from the transfer only after party
     A is connected to party C.

     localuri and localuriexpr are a Nuance extension that allows the user
     to specify the localuri, eg. ANI, for the outbound call.

     farenddialog and farenddialogexpr are a Nuance extension that allows
     specifying a VoiceXML dialog to execute with Party C to determine
     whether to connect Party A to Party C.

     warningtime and warningaudio are a Nuance extension to specify a
     prompt to play the specified amount of time before ending the
     bridge transfer due to maxtime.

     devicedetection is a Nuance extension specifying the list of devices
     that the system should attempt to detect on the transfer. -->
<!ELEMENT transfer (%audio; | %event.handler; | filled | grammar | prompt | property)*>
<!ATTLIST transfer
    %item.attrs;
    dest		%uri;		#IMPLIED
    destexpr	%expression;	#IMPLIED
    bridge		%boolean;	#IMPLIED
    connecttimeout	%duration;	#IMPLIED
    maxtime		%duration;	#IMPLIED
    transferaudio           %uri;   #IMPLIED
    aai         CDATA       #IMPLIED
    aaiexpr     %expression;    #IMPLIED
    type        (blind | bridge | conditional)  #IMPLIED
    localuri    %uri;       #IMPLIED
    localuriexpr    %expression;    #IMPLIED
    farenddialog            %uri;   #IMPLIED
    farenddialogexpr        %expression;   #IMPLIED
    warningtime %duration;  #IMPLIED
    warningaudio   %uri;   #IMPLIED
    devicedetection %devices; #IMPLIED
>


<!--============================ Control Flow ============================-->
<!ENTITY % if.attrs "cond		%expression;	#REQUIRED">

<!ELEMENT if 		(%executable.content; | elseif | else)*>
<!ATTLIST if
    %if.attrs;
>

<!ELEMENT elseif	EMPTY>
<!ATTLIST elseif
    %if.attrs;
>

<!ELEMENT else 	EMPTY>

<!ELEMENT exit		EMPTY>
<!ATTLIST exit
    expr		%expression;	#IMPLIED
    namelist	%variable.names;	#IMPLIED
>

<!ELEMENT filled 	(%executable.content;)*>
<!ATTLIST filled
    mode		(any | all)	"all"
    namelist	%variable.names;	#IMPLIED
>

<!ELEMENT goto		EMPTY>
<!ATTLIST goto
    %cache.attrs;
    %next.attrs;
    fetchaudio	%uri;		#IMPLIED
    expritem	%expression;	#IMPLIED
    nextitem	%variable.name;	#IMPLIED
>

<!-- <param> elements are allowed to have nested <param> children,
     and an index to allow building up arrays/vectors.
     Also, if index is specified name is not required. -->
<!ELEMENT param	(param)*>
<!ATTLIST param
    name		NMTOKEN		#IMPLIED
    expr		%expression;	#IMPLIED
    value		CDATA		#IMPLIED
    valuetype	(data | ref)	"data"
    type		CDATA		#IMPLIED
    index       CDATA       #IMPLIED
>

<!ELEMENT return	EMPTY>
<!ATTLIST return
    namelist	%variable.names;	#IMPLIED
    %throw.attrs;
>

<!ELEMENT subdialog (%audio; | %event.handler; | filled | param | prompt | property)*>
<!ATTLIST subdialog
    %item.attrs;
    src		%uri;		#IMPLIED
    srcexpr	%expression;		#IMPLIED
    %cache.attrs;
    fetchaudio	%uri;		#IMPLIED
    %submit.attrs;
>

<!ELEMENT submit	EMPTY>
<!ATTLIST submit
    %cache.attrs;
    %next.attrs;
    fetchaudio	%uri;		#IMPLIED
    %submit.attrs;
>


<!--========================== Verification  ==============================-->
<!-- The <voiceprint> tag is a FIA-based framework for verificaiton and identification. -->
<!ENTITY % voiceprint.plan.attrs
    'plan (verification | identification) "verification"
    designation %variable.names; #IMPLIED
    verification %variable.names; #IMPLIED
    training %variable.names; #IMPLIED
    completion %variable.names; #IMPLIED
    unanalyzed %variable.names; #IMPLIED
    adapt %boolean; #IMPLIED
    enroll %boolean; #IMPLIED'
>

<!ENTITY % voiceprint.repository.attrs
    'src %uri; #IMPLIED
    srcexpr %expression; #IMPLIED
    fetchnamelist %variable.names; #IMPLIED
    submitnamelist %variable.names; #IMPLIED'
>

<!ELEMENT nuance:voiceprint EMPTY>
<!ATTLIST nuance:voiceprint
    %voiceprint.plan.attrs;
    %voiceprint.repository.attrs;
>


<!--========================== Miscellaneous ==============================-->
<!-- <debug> is a deprecated version of the <log> tag.  Both link with Nuance's logging framework. -->
<!ELEMENT debug (#PCDATA | value)*>
<!ATTLIST debug
    expr			CDATA		#IMPLIED
    dest			%uri;		#IMPLIED
    level			NMTOKEN		#IMPLIED
>

<!ELEMENT log (#PCDATA | value)*>
<!ATTLIST log
    label			CDATA		#IMPLIED
    expr			%expression;		#IMPLIED
>

<!-- <link> under <object> is a Nuance extension. -->
<!ELEMENT object (%audio; | %event.handler; | filled | param | prompt | property | link)*>
<!ATTLIST object
    %item.attrs;
    %cache.attrs;
    classid		%uri;		#IMPLIED
    codebase	%uri;		#IMPLIED
    data		%uri;		#IMPLIED
    type		CDATA		#IMPLIED
    codetype	CDATA		#IMPLIED
    archive		%uri;		#IMPLIED
>

<!ELEMENT property	EMPTY>
<!ATTLIST property
    name		NMTOKEN		#REQUIRED
    value		CDATA		#REQUIRED
>

<!-- For debug purposes, newlines are preserved by default. -->
<!ELEMENT script	(#PCDATA)>
<!ATTLIST script
    src		%uri;		#IMPLIED
    charset		CDATA		#IMPLIED
    %cache.attrs;
    xml:space	(default|preserve)	#FIXED "preserve"
>

<!-- <nuance:nbest> is a Nuance extension that allows client side n-besting over
     multiple interpretations. -->
<!ELEMENT nuance:nbest	(#PCDATA)*>
<!ATTLIST nuance:nbest
    src		%uri;		#IMPLIED
    charset		CDATA		#IMPLIED
    %cache.attrs;
    xml:space	(default | preserve)	#FIXED "preserve"
>

<!--========================== Custom Elements ==============================-->
<!ELEMENT nuance:send   EMPTY >
<!ATTLIST nuance:send
    dest        %uri;           #IMPLIED
    destexpr    %expression;    #IMPLIED
    fetchaudio  %uri;           #IMPLIED
    %submit.attrs; >

