2 Copyright 2004 Sun Microsystems, Inc. All rights reserved.
3 SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
7 DTD for the JavaServer Faces Application Configuration File (Version 1.0)
9 To support validation of your configuration file(s), include the following
10 DOCTYPE element at the beginning (after the "xml" declaration):
12 <!DOCTYPE faces-config PUBLIC
13 "-//Sun Microsystems, Inc.//DTD JavaServer Faces Config 1.0//EN"
14 "http://java.sun.com/dtd/web-facesconfig_1_0.dtd">
16 $Id: web-facesconfig_1_0.dtd,v 1.31 2004/02/26 20:30:16 eburns Exp $
21 <!-- ==================== Defined Types =================================== -->
25 An "Action" is a String that represents a method binding
26 expression that points at a method with no arguments that returns a
27 String. It must be bracketed with "#{}", for example,
30 <!ENTITY % Action
"CDATA">
34 A "ClassName" is the fully qualified name of a Java class that is
35 instantiated to provide the functionality of the enclosing element.
37 <!ENTITY % ClassName
"CDATA">
41 An "Identifier" is a string of characters that conforms to the variable
42 naming conventions of the Java programming language (JLS Section ?.?.?).
44 <!ENTITY % Identifier
"CDATA">
48 A "JavaType" is either the fully qualified name of a Java class that is
49 instantiated to provide the functionality of the enclosing element, or
50 the name of a Java primitive type (such as int or char). The class name
51 or primitive type may optionally be followed by "[]" to indicate that
52 the underlying data must be an array, rather than a scalar variable.
54 <!ENTITY % JavaType
"CDATA">
58 A "Language" is a lower case two-letter code for a language as defined
61 <!ENTITY % Language
"CDATA">
65 A "ResourcePath" is the relative or absolute path to a resource file
66 (such as a logo image).
68 <!ENTITY % ResourcePath
"CDATA">
72 A "Scope" is the well-known name of a scope in which managed beans may
73 optionally be defined to be created in.
75 <!ENTITY % Scope
"(request|session|application)">
80 A "ScopeOrNone" element defines the legal values for the
81 <managed-bean-scope> element's body content, which includes
82 all of the scopes respresented by the "Scope" type, plus the
83 "none" value indicating that a created bean should not be
84 stored into any scope.
86 <!ENTITY % ScopeOrNone
"(request|session|application|none)">
90 A "ViewIdPattern" is a pattern for matching view identifiers in
91 order to determine whether a particular navigation rule should be
92 fired. It must contain one of the following values:
94 - The exact match for a view identifier that is recognized
95 by the the ViewHandler implementation being used (such as
96 "/index.jsp" if you are using the default ViewHandler).
98 - A proper prefix of a view identifier, plus a trailing "*"
99 character. This pattern indicates that all view identifiers that
100 match the portion of the pattern up to the asterisk will match the
101 surrounding rule. When more than one match exists, the match with
102 the longest pattern is selected.
104 - An "*" character, which means that this pattern applies to all
107 <!ENTITY % ViewIdPattern
"CDATA">
110 <!-- ==================== Top Level Elements ============================== -->
114 The "faces-config" element is the root of the configuration information
115 hierarchy, and contains nested elements for all of the other configuration
118 <!ELEMENT faces-config ((application|factory|component|converter|managed-bean|navigation-rule|referenced-bean|render-kit|lifecycle|validator)*)
>
119 <!ATTLIST faces-config
120 xmlns CDATA #FIXED
"http://java.sun.com/JSF/Configuration">
124 <!-- ==================== Definition Elements ============================= -->
128 The "application" element provides a mechanism to define the various
129 per-application-singleton implementation artifacts for a particular web
130 application that is utilizing JavaServer Faces. For nested elements
131 that are not specified, the JSF implementation must provide a suitable
134 <!ELEMENT application ((action-listener|default-render-kit-id|message-bundle|navigation-handler|view-handler|state-manager|property-resolver|variable-resolver|locale-config)*)
>
138 The "factory" element provides a mechanism to define the various
139 Factories that comprise parts of the implementation of JavaServer
140 Faces. For nested elements that are not specified, the JSF
141 implementation must provide a suitable default.
143 <!ELEMENT factory ((application-factory|faces-context-factory|lifecycle-factory|render-kit-factory)*)
>
147 The "attribute" element represents a named, typed, value associated with
148 the parent UIComponent via the generic attributes mechanism.
150 Attribute names must be unique within the scope of the parent (or related)
153 <!ELEMENT attribute (description*, display-name*, icon*, attribute-name, attribute-class, default-value?, suggested-value?, attribute-extension*)
>
156 Extension element for attribute. May contain implementation
159 <!ELEMENT attribute-extension ANY
>
163 The "component" element represents a concrete UIComponent implementation
164 class that should be registered under the specified type identifier,
165 along with its associated properties and attributes. Component types must
166 be unique within the entire web application.
168 Nested "attribute" elements identify generic attributes that are recognized
169 by the implementation logic of this component. Nested "property" elements
170 identify JavaBeans properties of the component class that may be exposed
171 for manipulation via tools.
173 <!ELEMENT component (description*, display-name*, icon*, component-type, component-class, attribute*, property*, component-extension*)
>
176 Extension element for component. May contain implementation
179 <!ELEMENT component-extension ANY
>
184 The "converter" element represents a concrete Converter implementation
185 class that should be registered under the specified converter identifier.
186 Converter identifiers must be unique within the entire web application.
188 Nested "attribute" elements identify generic attributes that may be
189 configured on the corresponding UIComponent in order to affect the
190 operation of the Converter. Nested "property" elements identify JavaBeans
191 properties of the Converter implementation class that may be configured
192 to affect the operation of the Converter.
194 <!ELEMENT converter (description*, display-name*, icon*, (converter-id | converter-for-class), converter-class, attribute*, property*)
>
198 The "icon" element contains "small-icon" and "large-icon" elements that
199 specify the resoruce paths for small and large GIF or JPG icon images
200 used to represent the parent element in a GUI tool.
202 <!ELEMENT icon (small-icon?, large-icon?)
>
203 <!ATTLIST icon xml:lang %Language; #IMPLIED
>
206 The "lifecycle" element provides a mechanism to specify
207 modifications to the behaviour of the default Lifecycle
208 implementation for this web application.
210 <!ELEMENT lifecycle (phase-listener*)
>
213 The "locale-config" element allows the app developer to declare the
214 supported locales for this application.
216 <!ELEMENT locale-config (default-locale?, supported-locale*)
>
219 The "managed-bean" element represents a JavaBean, of a particular class,
220 that will be dynamically instantiated at runtime (by the default
221 VariableResolver implementation) if it is referenced as the first element
222 of a value binding expression, and no corresponding bean can be
223 identified in any scope. In addition to the creation of the managed bean,
224 and the optional storing of it into the specified scope, the nested
225 managed-property elements can be used to initialize the contents of
226 settable JavaBeans properties of the created instance.
228 <!ELEMENT managed-bean (description*, display-name*, icon*, managed-bean-name, managed-bean-class, managed-bean-scope, (managed-property* | map-entries | list-entries))
>
232 The "managed-property" element represents an individual property of a
233 managed bean that will be configured to the specified value (or value set)
234 if the corresponding managed bean is automatically created.
236 <!ELEMENT managed-property (description*, display-name*, icon*, property-name, property-class?, (map-entries|null-value|value|list-entries))
>
240 The "map-entry" element reprsents a single key-entry pair that
241 will be added to the computed value of a managed property of type
244 <!ELEMENT map-entry (key, (null-value|value))
>
248 The "map-entries' element represents a set of key-entry pairs that
249 will be added to the computed value of a managed property of type
250 java.util.Map. In addition, the Java class types of the key and entry
251 values may be optionally declared.
253 <!ELEMENT map-entries (key-class?, value-class?, map-entry*)
>
257 The base name of a resource bundle representing the message resources
258 for this application. See the JavaDocs for the "java.util.ResourceBundle"
259 class for more information on the syntax of resource bundle names.
262 <!ELEMENT message-bundle (#PCDATA)
>
266 The "navigation-case" element describes a particular combination of
267 conditions that must match for this case to be executed, and the
268 view id of the component tree that should be selected next.
270 <!ELEMENT navigation-case (description*, display-name*, icon*, from-action?, from-outcome?, to-view-id, redirect?)
>
274 The "navigation-rule" element represents an individual decision rule
275 that will be utilized by the default NavigationHandler
276 implementation to make decisions on what view should be displayed
277 next, based on the view id being processed.
279 <!ELEMENT navigation-rule (description*, display-name*, icon*, from-view-id?, navigation-case*)
>
283 The "property" element represents a JavaBean property of the Java class
284 represented by our parent element.
286 Property names must be unique within the scope of the Java class
287 that is represented by the parent element, and must correspond to
288 property names that will be recognized when performing introspection
289 against that class via java.beans.Introspector.
291 <!ELEMENT property (description*, display-name*, icon*, property-name, property-class, default-value?, suggested-value?, property-extension*)
>
294 Extension element for property. May contain implementation
297 <!ELEMENT property-extension ANY
>
300 The "referenced-bean" element represents at design time the promise
301 that a Java object of the specified type will exist at runtime in some
302 scope, under the specified key. This can be used by design time tools
303 to construct user interface dialogs based on the properties of the
304 specified class. The presence or absence of a referenced bean
305 element has no impact on the JavaServer Faces runtime environment
306 inside a web application.
308 <!ELEMENT referenced-bean (description*, display-name*, icon*, referenced-bean-name, referenced-bean-class)
>
312 The "render-kit" element represents a concrete RenderKit implementation
313 that should be registered under the specified render-kit-id. If no
314 render-kit-id is specified, the identifier of the default RenderKit
315 (RenderKitFactory.DEFAULT_RENDER_KIT) is assumed.
317 <!ELEMENT render-kit (description*, display-name*, icon*, render-kit-id?, render-kit-class?, renderer*)
>
321 The "renderer" element represents a concrete Renderer implementation
322 class that should be registered under the specified component family
323 and renderer type identifiers, in the RenderKit associated with the
324 parent "render-kit" element. Combinations of component family and renderer
325 type must be unique within the RenderKit associated with the parent
326 "render-kit" element.
328 Nested "attribute" elements identify generic component attributes that
329 are recognized by this renderer.
331 <!ELEMENT renderer (description*, display-name*, icon*, component-family, renderer-type, renderer-class, attribute*, renderer-extension*)
>
334 Extension element for renderer. May contain implementation
337 <!ELEMENT renderer-extension ANY
>
340 The "validator" element represents a concrete Validator implementation
341 class that should be registered under the specified validator identifier.
342 Validator identifiers must be unique within the entire web application.
344 Nested "attribute" elements identify generic attributes that may be
345 configured on the corresponding UIComponent in order to affect the
346 operation of the Validator. Nested "property" elements identify JavaBeans
347 properties of the Validator implementation class that may be configured
348 to affect the operation of the Validator.
350 <!ELEMENT validator (description*, display-name*, icon*, validator-id, validator-class, attribute*, property*)
>
354 The "list-entries" element represents a set of initialization
355 elements for a managed property that is a java.util.List or an
356 array. In the former case, the "value-class" element can optionally
357 be used to declare the Java type to which each value should be
358 converted before adding it to the Collection.
360 <!ELEMENT list-entries (value-class?, (null-value|value)*)
>
363 <!-- ==================== Subordinate Elements ============================ -->
367 The "action-listener" element contains the fully qualified class name
368 of the concrete ActionListener implementation class that will be called
369 during the Invoke Application phase of the request processing lifecycle.
370 It must be of type "ClassName".
372 <!ELEMENT action-listener (#PCDATA)
>
375 The "application-factory" element contains the fully qualified class
376 name of the concrete ApplicationFactory implementation class that
377 will be called when FactoryFinder.getFactory(APPLICATION_FACTORY) is
378 called. It must be of type "ClassName".
380 <!ELEMENT application-factory (#PCDATA)
>
383 The "attribute-class" element represents the Java type of the value
384 associated with this attribute name. It must be of type "ClassName".
386 <!ELEMENT attribute-class (#PCDATA)
>
390 The "attribute-name" element represents the name under which the
391 corresponding value will be stored, in the generic attributes of the
392 UIComponent we are related to.
394 <!ELEMENT attribute-name (#PCDATA)
>
398 The "component-class" element represents the fully qualified class name
399 of a concrete UIComponent implementation class. It must be of
402 <!ELEMENT component-class (#PCDATA)
>
406 The "component-family" element represents the component family for
407 which the Renderer represented by the parent "renderer" element will be
410 <!ELEMENT component-family (#PCDATA)
>
413 The "component-type" element represents the name under which the
414 corresponding UIComponent class should be registered.
416 <!ELEMENT component-type (#PCDATA)
>
420 The "converter-class" element represents the fully qualified class name
421 of a concrete Converter implementation class. It must be of
424 <!ELEMENT converter-class (#PCDATA)
>
428 The "converter-for-class" element represents the fully qualified class name
429 for which a Converter class will be registered. It must be of
432 <!ELEMENT converter-for-class (#PCDATA)
>
436 The "converter-id" element represents the identifier under which the
437 corresponding Converter class should be registered.
439 <!ELEMENT converter-id (#PCDATA)
>
442 The "default-render-kit-id" element allows the application to define
443 a renderkit to be used other than the standard one.
445 <!ELEMENT default-render-kit-id (#PCDATA)
>
448 The "default-locale" element declares the default locale for this
449 application instance. It must be specified as
450 :language:[_:country:[_:variant:]] without the colons, for example
451 "ja_JP_SJIS". The separators between the segments may be '-' or
454 <!ELEMENT default-locale (#PCDATA)
>
457 The "default-value" contains the value for the property or attribute
458 in which this element resides. This value differs from the
459 "suggested-value" in that the property or attribute must take the
460 value, whereas in "suggested-value" taking the value is optional.
462 <!ELEMENT default-value (#PCDATA)
>
465 The "description" element contains a textual description of the element
466 it is nested in, optionally flagged with a language code using the
467 "xml:lang" attribute.
469 <!ELEMENT description ANY
>
470 <!ATTLIST description xml:lang %Language; #IMPLIED
>
474 The "display-name" element is a short descriptive name describing the
475 entity associated with the element it is nested in, intended to be
476 displayed by tools, and optionally flagged with a language code using
477 the "xml:lang" attribute.
479 <!ELEMENT display-name (#PCDATA)
>
480 <!ATTLIST display-name xml:lang %Language; #IMPLIED
>
483 The "faces-context-factory" element contains the fully qualified
484 class name of the concrete FacesContextFactory implementation class
485 that will be called when
486 FactoryFinder.getFactory(FACES_CONTEXT_FACTORY) is called. It must
487 be of type "ClassName".
489 <!ELEMENT faces-context-factory (#PCDATA)
>
492 The "from-action" element contains an action reference expression
493 that must have been executed (by the default ActionListener for handling
494 application level events) in order to select this navigation rule. If
495 not specified, this rule will be relevant no matter which action reference
496 was executed (or if no action reference was executed).
498 This value must be of type "Action".
500 <!ELEMENT from-action (#PCDATA)
>
504 The "from-outcome" element contains a logical outcome string returned
505 by the execution of an application action method selected via an
506 "actionRef" property (or a literal value specified by an "action"
507 property) of a UICommand component. If specified, this rule will be
508 relevant only if the outcome value matches this element's value. If
509 not specified, this rule will be relevant no matter what the outcome
512 <!ELEMENT from-outcome (#PCDATA)
>
516 The "from-view-id" element contains the view identifier of the view
517 for which the containing navigation rule is relevant. If no
518 "from-view" element is specified, this rule applies to navigation
519 decisions on all views. If this element is not specified, a value
520 of "*" is assumed, meaning that this navigation rule applies to all
523 This value must be of type "ViewIdPattern".
525 <!ELEMENT from-view-id (#PCDATA)
>
529 The "key" element is the String representation of a map key that
530 will be stored in a managed property of type java.util.Map.
532 <!ELEMENT key (#PCDATA)
>
536 The "key-class" element defines the Java type to which each "key"
537 element in a set of "map-entry" elements will be converted to. It
538 must be of type "ClassName". If omitted, "java.lang.String"
541 <!ELEMENT key-class (#PCDATA)
>
545 The "large-icon" element contains the resource path to a large (32x32)
546 icon image. The image may be in either GIF or JPG format.
548 <!ELEMENT large-icon (#PCDATA)
>
551 The "lifecycle-factory" element contains the fully qualified class name
552 of the concrete LifecycleFactory implementation class that will be called
553 when FactoryFinder.getFactory(LIFECYCLE_FACTORY) is called. It must be
556 <!ELEMENT lifecycle-factory (#PCDATA)
>
559 The "managed-bean-class" element represents the fully qualified class
560 name of the Java class that will be used to instantiate a new instance
561 if creation of the specified managed bean is requested. It must be of
564 The specified class must conform to standard JavaBeans conventions.
565 In particular, it must have a public zero-arguments constructor, and
566 zero or more public property setters.
568 <!ELEMENT managed-bean-class (#PCDATA)
>
572 The "managed-bean-name" element represents the attribute name under
573 which a managed bean will be searched for, as well as stored (unless
574 the "managed-bean-scope" value is "none"). It must be of type
577 <!ELEMENT managed-bean-name (#PCDATA)
>
581 The "managed-bean-scope" element represents the scope into which a newly
582 created instance of the specified managed bean will be stored (unless
583 the value is "none"). It must be of type "ScopeOrNone".
585 <!ELEMENT managed-bean-scope (#PCDATA)
>
588 The "navigation-handler" element contains the fully qualified class name
589 of the concrete NavigationHandler implementation class that will be called
590 during the Invoke Application phase of the request processing lifecycle,
591 if the default ActionListener (provided by the JSF implementation) is used.
592 It must be of type "ClassName".
594 <!ELEMENT navigation-handler (#PCDATA)
>
597 The "phase-listener" element contains the fully qualified class
598 name of the concrete PhaseListener implementation class that will be
599 registered on the Lifecycle. It must be of type "ClassName".
601 <!ELEMENT phase-listener (#PCDATA)
>
604 The "redirect" element indicates that navigation to the specified
605 "to-view-id" should be accomplished by performing an HTTP redirect
606 rather than the usual ViewHandler mechanisms.
608 <!ELEMENT redirect EMPTY
>
611 The "suggested-value" contains the value for the property or
612 attribute in which this element resides. This value is advisory
613 only and is intended for tools to use when populating pallettes.
615 <!ELEMENT suggested-value (#PCDATA)
>
620 The "view-handler" element contains the fully qualified class name
621 of the concrete ViewHandler implementation class that will be called
622 during the Restore View and Render Response phases of the request
623 processing lifecycle. The faces implementation must provide a
624 default implementation of this class
626 <!ELEMENT view-handler (#PCDATA)
>
630 The "state-manager" element contains the fully qualified class name
631 of the concrete StateManager implementation class that will be called
632 during the Restore View and Render Response phases of the request
633 processing lifecycle. The faces implementation must provide a
634 default implementation of this class
636 <!ELEMENT state-manager (#PCDATA)
>
639 The "null-value" element indicates that the managed property in which we
640 are nested will be explicitly set to null if our managed bean is
641 automatically created. This is different from omitting the managed
642 property element entirely, which will cause no property setter to be
643 called for this property.
645 The "null-value" element can only be used when the associated
646 "property-class" identifies a Java class, not a Java primitive.
648 <!ELEMENT null-value EMPTY
>
652 The "property-class" element represents the Java type of the value
653 associated with this property name. It must be of type "JavaType".
654 If not specified, it can be inferred from existing classes; however,
655 this element should be specified if the configuration file is going
656 to be the source for generating the corresponding classes.
658 <!ELEMENT property-class (#PCDATA)
>
662 The "property-name" element represents the JavaBeans property name
663 under which the corresponding value may be stored.
665 <!ELEMENT property-name (#PCDATA)
>
669 The "property-resolver" element contains the fully qualified class name
670 of the concrete PropertyResolver implementation class that will be used
671 during the processing of value binding expressions.
672 It must be of type "ClassName".
674 <!ELEMENT property-resolver (#PCDATA)
>
678 The "referenced-bean-class" element represents the fully qualified class
679 name of the Java class (either abstract or concrete) or Java interface
680 implemented by the corresponding referenced bean. It must be of type
683 <!ELEMENT referenced-bean-class (#PCDATA)
>
687 The "referenced-bean-name" element represents the attribute name under
688 which the corresponding referenced bean may be assumed to be stored,
689 in one of the scopes defined by the "Scope" type. It must be of type
692 <!ELEMENT referenced-bean-name (#PCDATA)
>
696 The "render-kit-id" element represents an identifier for the
697 RenderKit represented by the parent "render-kit" element.
699 <!ELEMENT render-kit-id (#PCDATA)
>
703 The "render-kit-class" element represents the fully qualified class name
704 of a concrete RenderKit implementation class. It must be of
707 <!ELEMENT render-kit-class (#PCDATA)
>
711 The "renderer-class" element represents the fully qualified class name
712 of a concrete Renderer implementation class. It must be of
715 <!ELEMENT renderer-class (#PCDATA)
>
718 The "render-kit-factory" element contains the fully qualified class name
719 of the concrete RenderKitFactory implementation class that will be called
720 when FactoryFinder.getFactory(RENDER_KIT_FACTORY) is called. It must be
723 <!ELEMENT render-kit-factory (#PCDATA)
>
726 The "renderer-type" element represents a renderer type identifier for the
727 Renderer represented by the parent "renderer" element.
729 <!ELEMENT renderer-type (#PCDATA)
>
732 The "small-icon" element contains the resource path to a large (16x16)
733 icon image. The image may be in either GIF or JPG format.
735 <!ELEMENT small-icon (#PCDATA)
>
738 The "supported-locale" element allows authors to declare which
739 locales are supported in this application instance.
741 It must be specified as :language:[_:country:[_:variant:]] without
742 the colons, for example "ja_JP_SJIS". The separators between the
743 segments may be '-' or '_'.
745 <!ELEMENT supported-locale (#PCDATA)
>
748 The "to-view" element contains the view identifier of the next view
749 that should be displayed if this navigation rule is matched. It
750 must be of type "ViewId".
752 <!ELEMENT to-view-id (#PCDATA)
>
756 The "validator-class" element represents the fully qualified class name
757 of a concrete Validator implementation class. It must be of
760 <!ELEMENT validator-class (#PCDATA)
>
764 The "validator-id" element represents the identifier under which the
765 corresponding Validator class should be registered.
767 <!ELEMENT validator-id (#PCDATA)
>
771 The "value" element is the String representation of a literal
772 value to which a scalar managed property will be set, or a value
773 binding expression ("#{...}") that will be used to calculate the
774 required value. It will be converted as specified for the actual
777 <!ELEMENT value (#PCDATA)
>
781 The "value-class" element defines the Java type to which each
782 "value" element's value will be converted to, prior to adding it to
783 the "list-entries" list for a managed property that is a
784 java.util.List, or a "map-entries" map for a managed property that
785 is a java.util.Map. It must be of type "ClassName". If omitted,
786 "java.lang.String" is assumed.
788 <!ELEMENT value-class (#PCDATA)
>
791 The "variable-resolver" element contains the fully qualified class name
792 of the concrete VariableResolver implementation class that will be used
793 during the processing of value binding expressions.
794 It must be of type "ClassName".
796 <!ELEMENT variable-resolver (#PCDATA)
>
799 <!-- ============================ Identifier Attributes ==================== -->
802 <!ATTLIST action-listener id ID #IMPLIED
>
803 <!ATTLIST application id ID #IMPLIED
>
804 <!ATTLIST application-factory id ID #IMPLIED
>
805 <!ATTLIST attribute id ID #IMPLIED
>
806 <!ATTLIST attribute-class id ID #IMPLIED
>
807 <!ATTLIST attribute-extension id ID #IMPLIED
>
808 <!ATTLIST attribute-name id ID #IMPLIED
>
809 <!ATTLIST component id ID #IMPLIED
>
810 <!ATTLIST component-class id ID #IMPLIED
>
811 <!ATTLIST component-extension id ID #IMPLIED
>
812 <!ATTLIST component-family id ID #IMPLIED
>
813 <!ATTLIST component-type id ID #IMPLIED
>
814 <!ATTLIST converter id ID #IMPLIED
>
815 <!ATTLIST converter-class id ID #IMPLIED
>
816 <!ATTLIST converter-for-class id ID #IMPLIED
>
817 <!ATTLIST converter-id id ID #IMPLIED
>
818 <!ATTLIST default-locale id ID #IMPLIED
>
819 <!ATTLIST default-render-kit-id id ID #IMPLIED
>
820 <!ATTLIST default-value id ID #IMPLIED
>
821 <!ATTLIST description id ID #IMPLIED
>
822 <!ATTLIST display-name id ID #IMPLIED
>
823 <!ATTLIST faces-config id ID #IMPLIED
>
824 <!ATTLIST faces-context-factory id ID #IMPLIED
>
825 <!ATTLIST factory id ID #IMPLIED
>
826 <!ATTLIST from-action id ID #IMPLIED
>
827 <!ATTLIST from-outcome id ID #IMPLIED
>
828 <!ATTLIST from-view-id id ID #IMPLIED
>
829 <!ATTLIST icon id ID #IMPLIED
>
830 <!ATTLIST key id ID #IMPLIED
>
831 <!ATTLIST key-class id ID #IMPLIED
>
832 <!ATTLIST large-icon id ID #IMPLIED
>
833 <!ATTLIST lifecycle id ID #IMPLIED
>
834 <!ATTLIST lifecycle-factory id ID #IMPLIED
>
835 <!ATTLIST list-entries id ID #IMPLIED
>
836 <!ATTLIST locale-config id ID #IMPLIED
>
837 <!ATTLIST managed-bean id ID #IMPLIED
>
838 <!ATTLIST managed-bean-class id ID #IMPLIED
>
839 <!ATTLIST managed-bean-name id ID #IMPLIED
>
840 <!ATTLIST managed-bean-scope id ID #IMPLIED
>
841 <!ATTLIST managed-property id ID #IMPLIED
>
842 <!ATTLIST map-entries id ID #IMPLIED
>
843 <!ATTLIST map-entry id ID #IMPLIED
>
844 <!ATTLIST message-bundle id ID #IMPLIED
>
845 <!ATTLIST navigation-case id ID #IMPLIED
>
846 <!ATTLIST navigation-handler id ID #IMPLIED
>
847 <!ATTLIST navigation-rule id ID #IMPLIED
>
848 <!ATTLIST null-value id ID #IMPLIED
>
849 <!ATTLIST phase-listener id ID #IMPLIED
>
850 <!ATTLIST property id ID #IMPLIED
>
851 <!ATTLIST property-class id ID #IMPLIED
>
852 <!ATTLIST property-extension id ID #IMPLIED
>
853 <!ATTLIST property-name id ID #IMPLIED
>
854 <!ATTLIST property-resolver id ID #IMPLIED
>
855 <!ATTLIST redirect id ID #IMPLIED
>
856 <!ATTLIST referenced-bean id ID #IMPLIED
>
857 <!ATTLIST referenced-bean-class id ID #IMPLIED
>
858 <!ATTLIST referenced-bean-name id ID #IMPLIED
>
859 <!ATTLIST render-kit id ID #IMPLIED
>
860 <!ATTLIST render-kit-class id ID #IMPLIED
>
861 <!ATTLIST render-kit-factory id ID #IMPLIED
>
862 <!ATTLIST render-kit-id id ID #IMPLIED
>
863 <!ATTLIST renderer id ID #IMPLIED
>
864 <!ATTLIST renderer-class id ID #IMPLIED
>
865 <!ATTLIST renderer-extension id ID #IMPLIED
>
866 <!ATTLIST renderer-type id ID #IMPLIED
>
867 <!ATTLIST small-icon id ID #IMPLIED
>
868 <!ATTLIST state-manager id ID #IMPLIED
>
869 <!ATTLIST suggested-value id ID #IMPLIED
>
870 <!ATTLIST supported-locale id ID #IMPLIED
>
871 <!ATTLIST to-view-id id ID #IMPLIED
>
872 <!ATTLIST validator id ID #IMPLIED
>
873 <!ATTLIST validator-class id ID #IMPLIED
>
874 <!ATTLIST validator-id id ID #IMPLIED
>
875 <!ATTLIST value id ID #IMPLIED
>
876 <!ATTLIST value-class id ID #IMPLIED
>
877 <!ATTLIST variable-resolver id ID #IMPLIED
>
878 <!ATTLIST view-handler id ID #IMPLIED
>