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.1)
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.1//EN"
14 "http://java.sun.com/dtd/web-facesconfig_1_1.dtd">
16 $Id: web-facesconfig_1_1.dtd,v 1.3 2004/04/27 14:01:47 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, facet*, attribute*, property*, component-extension*)
>
176 Extension element for component. May contain implementation
179 <!ELEMENT component-extension ANY
>
182 Define the name and other design-time information for a facet that is
183 associated with a renderer or a component.
186 <!ELEMENT facet (description*, display-name*, icon*, facet-name, facet-extension*)
>
189 Extension element for facet. May contain implementation
192 <!ELEMENT facet-extension ANY
>
195 The "facet-name" element represents the facet name under which a
196 UIComponent will be added to its parent. It must be of type
199 <!ELEMENT facet-name (#PCDATA)
>
202 The "converter" element represents a concrete Converter implementation
203 class that should be registered under the specified converter identifier.
204 Converter identifiers must be unique within the entire web application.
206 Nested "attribute" elements identify generic attributes that may be
207 configured on the corresponding UIComponent in order to affect the
208 operation of the Converter. Nested "property" elements identify JavaBeans
209 properties of the Converter implementation class that may be configured
210 to affect the operation of the Converter.
212 <!ELEMENT converter (description*, display-name*, icon*, (converter-id | converter-for-class), converter-class, attribute*, property*)
>
216 The "icon" element contains "small-icon" and "large-icon" elements that
217 specify the resoruce paths for small and large GIF or JPG icon images
218 used to represent the parent element in a GUI tool.
220 <!ELEMENT icon (small-icon?, large-icon?)
>
221 <!ATTLIST icon xml:lang %Language; #IMPLIED
>
224 The "lifecycle" element provides a mechanism to specify
225 modifications to the behaviour of the default Lifecycle
226 implementation for this web application.
228 <!ELEMENT lifecycle (phase-listener*)
>
231 The "locale-config" element allows the app developer to declare the
232 supported locales for this application.
234 <!ELEMENT locale-config (default-locale?, supported-locale*)
>
237 The "managed-bean" element represents a JavaBean, of a particular class,
238 that will be dynamically instantiated at runtime (by the default
239 VariableResolver implementation) if it is referenced as the first element
240 of a value binding expression, and no corresponding bean can be
241 identified in any scope. In addition to the creation of the managed bean,
242 and the optional storing of it into the specified scope, the nested
243 managed-property elements can be used to initialize the contents of
244 settable JavaBeans properties of the created instance.
246 <!ELEMENT managed-bean (description*, display-name*, icon*, managed-bean-name, managed-bean-class, managed-bean-scope, (managed-property* | map-entries | list-entries))
>
250 The "managed-property" element represents an individual property of a
251 managed bean that will be configured to the specified value (or value set)
252 if the corresponding managed bean is automatically created.
254 <!ELEMENT managed-property (description*, display-name*, icon*, property-name, property-class?, (map-entries|null-value|value|list-entries))
>
258 The "map-entry" element reprsents a single key-entry pair that
259 will be added to the computed value of a managed property of type
262 <!ELEMENT map-entry (key, (null-value|value))
>
266 The "map-entries' element represents a set of key-entry pairs that
267 will be added to the computed value of a managed property of type
268 java.util.Map. In addition, the Java class types of the key and entry
269 values may be optionally declared.
271 <!ELEMENT map-entries (key-class?, value-class?, map-entry*)
>
275 The base name of a resource bundle representing the message resources
276 for this application. See the JavaDocs for the "java.util.ResourceBundle"
277 class for more information on the syntax of resource bundle names.
280 <!ELEMENT message-bundle (#PCDATA)
>
284 The "navigation-case" element describes a particular combination of
285 conditions that must match for this case to be executed, and the
286 view id of the component tree that should be selected next.
288 <!ELEMENT navigation-case (description*, display-name*, icon*, from-action?, from-outcome?, to-view-id, redirect?)
>
292 The "navigation-rule" element represents an individual decision rule
293 that will be utilized by the default NavigationHandler
294 implementation to make decisions on what view should be displayed
295 next, based on the view id being processed.
297 <!ELEMENT navigation-rule (description*, display-name*, icon*, from-view-id?, navigation-case*)
>
301 The "property" element represents a JavaBean property of the Java class
302 represented by our parent element.
304 Property names must be unique within the scope of the Java class
305 that is represented by the parent element, and must correspond to
306 property names that will be recognized when performing introspection
307 against that class via java.beans.Introspector.
309 <!ELEMENT property (description*, display-name*, icon*, property-name, property-class, default-value?, suggested-value?, property-extension*)
>
312 Extension element for property. May contain implementation
315 <!ELEMENT property-extension ANY
>
318 The "referenced-bean" element represents at design time the promise
319 that a Java object of the specified type will exist at runtime in some
320 scope, under the specified key. This can be used by design time tools
321 to construct user interface dialogs based on the properties of the
322 specified class. The presence or absence of a referenced bean
323 element has no impact on the JavaServer Faces runtime environment
324 inside a web application.
326 <!ELEMENT referenced-bean (description*, display-name*, icon*, referenced-bean-name, referenced-bean-class)
>
330 The "render-kit" element represents a concrete RenderKit implementation
331 that should be registered under the specified render-kit-id. If no
332 render-kit-id is specified, the identifier of the default RenderKit
333 (RenderKitFactory.DEFAULT_RENDER_KIT) is assumed.
335 <!ELEMENT render-kit (description*, display-name*, icon*, render-kit-id?, render-kit-class?, renderer*)
>
339 The "renderer" element represents a concrete Renderer implementation
340 class that should be registered under the specified component family
341 and renderer type identifiers, in the RenderKit associated with the
342 parent "render-kit" element. Combinations of component family and renderer
343 type must be unique within the RenderKit associated with the parent
344 "render-kit" element.
346 Nested "attribute" elements identify generic component attributes that
347 are recognized by this renderer.
349 <!ELEMENT renderer (description*, display-name*, icon*, component-family, renderer-type, renderer-class, facet*, attribute*, renderer-extension*)
>
352 Extension element for renderer. May contain implementation
355 <!ELEMENT renderer-extension ANY
>
358 The "validator" element represents a concrete Validator implementation
359 class that should be registered under the specified validator identifier.
360 Validator identifiers must be unique within the entire web application.
362 Nested "attribute" elements identify generic attributes that may be
363 configured on the corresponding UIComponent in order to affect the
364 operation of the Validator. Nested "property" elements identify JavaBeans
365 properties of the Validator implementation class that may be configured
366 to affect the operation of the Validator.
368 <!ELEMENT validator (description*, display-name*, icon*, validator-id, validator-class, attribute*, property*)
>
372 The "list-entries" element represents a set of initialization
373 elements for a managed property that is a java.util.List or an
374 array. In the former case, the "value-class" element can optionally
375 be used to declare the Java type to which each value should be
376 converted before adding it to the Collection.
378 <!ELEMENT list-entries (value-class?, (null-value|value)*)
>
381 <!-- ==================== Subordinate Elements ============================ -->
385 The "action-listener" element contains the fully qualified class name
386 of the concrete ActionListener implementation class that will be called
387 during the Invoke Application phase of the request processing lifecycle.
388 It must be of type "ClassName".
390 <!ELEMENT action-listener (#PCDATA)
>
393 The "application-factory" element contains the fully qualified class
394 name of the concrete ApplicationFactory implementation class that
395 will be called when FactoryFinder.getFactory(APPLICATION_FACTORY) is
396 called. It must be of type "ClassName".
398 <!ELEMENT application-factory (#PCDATA)
>
401 The "attribute-class" element represents the Java type of the value
402 associated with this attribute name. It must be of type "ClassName".
404 <!ELEMENT attribute-class (#PCDATA)
>
408 The "attribute-name" element represents the name under which the
409 corresponding value will be stored, in the generic attributes of the
410 UIComponent we are related to.
412 <!ELEMENT attribute-name (#PCDATA)
>
416 The "component-class" element represents the fully qualified class name
417 of a concrete UIComponent implementation class. It must be of
420 <!ELEMENT component-class (#PCDATA)
>
424 The "component-family" element represents the component family for
425 which the Renderer represented by the parent "renderer" element will be
428 <!ELEMENT component-family (#PCDATA)
>
431 The "component-type" element represents the name under which the
432 corresponding UIComponent class should be registered.
434 <!ELEMENT component-type (#PCDATA)
>
438 The "converter-class" element represents the fully qualified class name
439 of a concrete Converter implementation class. It must be of
442 <!ELEMENT converter-class (#PCDATA)
>
446 The "converter-for-class" element represents the fully qualified class name
447 for which a Converter class will be registered. It must be of
450 <!ELEMENT converter-for-class (#PCDATA)
>
454 The "converter-id" element represents the identifier under which the
455 corresponding Converter class should be registered.
457 <!ELEMENT converter-id (#PCDATA)
>
460 The "default-render-kit-id" element allows the application to define
461 a renderkit to be used other than the standard one.
463 <!ELEMENT default-render-kit-id (#PCDATA)
>
466 The "default-locale" element declares the default locale for this
467 application instance. It must be specified as
468 :language:[_:country:[_:variant:]] without the colons, for example
469 "ja_JP_SJIS". The separators between the segments may be '-' or
472 <!ELEMENT default-locale (#PCDATA)
>
475 The "default-value" contains the value for the property or attribute
476 in which this element resides. This value differs from the
477 "suggested-value" in that the property or attribute must take the
478 value, whereas in "suggested-value" taking the value is optional.
480 <!ELEMENT default-value (#PCDATA)
>
483 The "description" element contains a textual description of the element
484 it is nested in, optionally flagged with a language code using the
485 "xml:lang" attribute.
487 <!ELEMENT description ANY
>
488 <!ATTLIST description xml:lang %Language; #IMPLIED
>
492 The "display-name" element is a short descriptive name describing the
493 entity associated with the element it is nested in, intended to be
494 displayed by tools, and optionally flagged with a language code using
495 the "xml:lang" attribute.
497 <!ELEMENT display-name (#PCDATA)
>
498 <!ATTLIST display-name xml:lang %Language; #IMPLIED
>
501 The "faces-context-factory" element contains the fully qualified
502 class name of the concrete FacesContextFactory implementation class
503 that will be called when
504 FactoryFinder.getFactory(FACES_CONTEXT_FACTORY) is called. It must
505 be of type "ClassName".
507 <!ELEMENT faces-context-factory (#PCDATA)
>
510 The "from-action" element contains an action reference expression
511 that must have been executed (by the default ActionListener for handling
512 application level events) in order to select this navigation rule. If
513 not specified, this rule will be relevant no matter which action reference
514 was executed (or if no action reference was executed).
516 This value must be of type "Action".
518 <!ELEMENT from-action (#PCDATA)
>
522 The "from-outcome" element contains a logical outcome string returned
523 by the execution of an application action method selected via an
524 "actionRef" property (or a literal value specified by an "action"
525 property) of a UICommand component. If specified, this rule will be
526 relevant only if the outcome value matches this element's value. If
527 not specified, this rule will be relevant no matter what the outcome
530 <!ELEMENT from-outcome (#PCDATA)
>
534 The "from-view-id" element contains the view identifier of the view
535 for which the containing navigation rule is relevant. If no
536 "from-view" element is specified, this rule applies to navigation
537 decisions on all views. If this element is not specified, a value
538 of "*" is assumed, meaning that this navigation rule applies to all
541 This value must be of type "ViewIdPattern".
543 <!ELEMENT from-view-id (#PCDATA)
>
547 The "key" element is the String representation of a map key that
548 will be stored in a managed property of type java.util.Map.
550 <!ELEMENT key (#PCDATA)
>
554 The "key-class" element defines the Java type to which each "key"
555 element in a set of "map-entry" elements will be converted to. It
556 must be of type "ClassName". If omitted, "java.lang.String"
559 <!ELEMENT key-class (#PCDATA)
>
563 The "large-icon" element contains the resource path to a large (32x32)
564 icon image. The image may be in either GIF or JPG format.
566 <!ELEMENT large-icon (#PCDATA)
>
569 The "lifecycle-factory" element contains the fully qualified class name
570 of the concrete LifecycleFactory implementation class that will be called
571 when FactoryFinder.getFactory(LIFECYCLE_FACTORY) is called. It must be
574 <!ELEMENT lifecycle-factory (#PCDATA)
>
577 The "managed-bean-class" element represents the fully qualified class
578 name of the Java class that will be used to instantiate a new instance
579 if creation of the specified managed bean is requested. It must be of
582 The specified class must conform to standard JavaBeans conventions.
583 In particular, it must have a public zero-arguments constructor, and
584 zero or more public property setters.
586 <!ELEMENT managed-bean-class (#PCDATA)
>
590 The "managed-bean-name" element represents the attribute name under
591 which a managed bean will be searched for, as well as stored (unless
592 the "managed-bean-scope" value is "none"). It must be of type
595 <!ELEMENT managed-bean-name (#PCDATA)
>
599 The "managed-bean-scope" element represents the scope into which a newly
600 created instance of the specified managed bean will be stored (unless
601 the value is "none"). It must be of type "ScopeOrNone".
603 <!ELEMENT managed-bean-scope (#PCDATA)
>
606 The "navigation-handler" element contains the fully qualified class name
607 of the concrete NavigationHandler implementation class that will be called
608 during the Invoke Application phase of the request processing lifecycle,
609 if the default ActionListener (provided by the JSF implementation) is used.
610 It must be of type "ClassName".
612 <!ELEMENT navigation-handler (#PCDATA)
>
615 The "phase-listener" element contains the fully qualified class
616 name of the concrete PhaseListener implementation class that will be
617 registered on the Lifecycle. It must be of type "ClassName".
619 <!ELEMENT phase-listener (#PCDATA)
>
622 The "redirect" element indicates that navigation to the specified
623 "to-view-id" should be accomplished by performing an HTTP redirect
624 rather than the usual ViewHandler mechanisms.
626 <!ELEMENT redirect EMPTY
>
629 The "suggested-value" contains the value for the property or
630 attribute in which this element resides. This value is advisory
631 only and is intended for tools to use when populating pallettes.
633 <!ELEMENT suggested-value (#PCDATA)
>
638 The "view-handler" element contains the fully qualified class name
639 of the concrete ViewHandler implementation class that will be called
640 during the Restore View and Render Response phases of the request
641 processing lifecycle. The faces implementation must provide a
642 default implementation of this class
644 <!ELEMENT view-handler (#PCDATA)
>
648 The "state-manager" element contains the fully qualified class name
649 of the concrete StateManager implementation class that will be called
650 during the Restore View and Render Response phases of the request
651 processing lifecycle. The faces implementation must provide a
652 default implementation of this class
654 <!ELEMENT state-manager (#PCDATA)
>
657 The "null-value" element indicates that the managed property in which we
658 are nested will be explicitly set to null if our managed bean is
659 automatically created. This is different from omitting the managed
660 property element entirely, which will cause no property setter to be
661 called for this property.
663 The "null-value" element can only be used when the associated
664 "property-class" identifies a Java class, not a Java primitive.
666 <!ELEMENT null-value EMPTY
>
670 The "property-class" element represents the Java type of the value
671 associated with this property name. It must be of type "JavaType".
672 If not specified, it can be inferred from existing classes; however,
673 this element should be specified if the configuration file is going
674 to be the source for generating the corresponding classes.
676 <!ELEMENT property-class (#PCDATA)
>
680 The "property-name" element represents the JavaBeans property name
681 under which the corresponding value may be stored.
683 <!ELEMENT property-name (#PCDATA)
>
687 The "property-resolver" element contains the fully qualified class name
688 of the concrete PropertyResolver implementation class that will be used
689 during the processing of value binding expressions.
690 It must be of type "ClassName".
692 <!ELEMENT property-resolver (#PCDATA)
>
696 The "referenced-bean-class" element represents the fully qualified class
697 name of the Java class (either abstract or concrete) or Java interface
698 implemented by the corresponding referenced bean. It must be of type
701 <!ELEMENT referenced-bean-class (#PCDATA)
>
705 The "referenced-bean-name" element represents the attribute name under
706 which the corresponding referenced bean may be assumed to be stored,
707 in one of the scopes defined by the "Scope" type. It must be of type
710 <!ELEMENT referenced-bean-name (#PCDATA)
>
714 The "render-kit-id" element represents an identifier for the
715 RenderKit represented by the parent "render-kit" element.
717 <!ELEMENT render-kit-id (#PCDATA)
>
721 The "render-kit-class" element represents the fully qualified class name
722 of a concrete RenderKit implementation class. It must be of
725 <!ELEMENT render-kit-class (#PCDATA)
>
729 The "renderer-class" element represents the fully qualified class name
730 of a concrete Renderer implementation class. It must be of
733 <!ELEMENT renderer-class (#PCDATA)
>
736 The "render-kit-factory" element contains the fully qualified class name
737 of the concrete RenderKitFactory implementation class that will be called
738 when FactoryFinder.getFactory(RENDER_KIT_FACTORY) is called. It must be
741 <!ELEMENT render-kit-factory (#PCDATA)
>
744 The "renderer-type" element represents a renderer type identifier for the
745 Renderer represented by the parent "renderer" element.
747 <!ELEMENT renderer-type (#PCDATA)
>
750 The "small-icon" element contains the resource path to a large (16x16)
751 icon image. The image may be in either GIF or JPG format.
753 <!ELEMENT small-icon (#PCDATA)
>
756 The "supported-locale" element allows authors to declare which
757 locales are supported in this application instance.
759 It must be specified as :language:[_:country:[_:variant:]] without
760 the colons, for example "ja_JP_SJIS". The separators between the
761 segments may be '-' or '_'.
763 <!ELEMENT supported-locale (#PCDATA)
>
766 The "to-view" element contains the view identifier of the next view
767 that should be displayed if this navigation rule is matched. It
768 must be of type "ViewId".
770 <!ELEMENT to-view-id (#PCDATA)
>
774 The "validator-class" element represents the fully qualified class name
775 of a concrete Validator implementation class. It must be of
778 <!ELEMENT validator-class (#PCDATA)
>
782 The "validator-id" element represents the identifier under which the
783 corresponding Validator class should be registered.
785 <!ELEMENT validator-id (#PCDATA)
>
789 The "value" element is the String representation of a literal
790 value to which a scalar managed property will be set, or a value
791 binding expression ("#{...}") that will be used to calculate the
792 required value. It will be converted as specified for the actual
795 <!ELEMENT value (#PCDATA)
>
799 The "value-class" element defines the Java type to which each
800 "value" element's value will be converted to, prior to adding it to
801 the "list-entries" list for a managed property that is a
802 java.util.List, or a "map-entries" map for a managed property that
803 is a java.util.Map. It must be of type "ClassName". If omitted,
804 "java.lang.String" is assumed.
806 <!ELEMENT value-class (#PCDATA)
>
809 The "variable-resolver" element contains the fully qualified class name
810 of the concrete VariableResolver implementation class that will be used
811 during the processing of value binding expressions.
812 It must be of type "ClassName".
814 <!ELEMENT variable-resolver (#PCDATA)
>
817 <!-- ============================ Identifier Attributes ==================== -->
820 <!ATTLIST action-listener id ID #IMPLIED
>
821 <!ATTLIST application id ID #IMPLIED
>
822 <!ATTLIST application-factory id ID #IMPLIED
>
823 <!ATTLIST attribute id ID #IMPLIED
>
824 <!ATTLIST attribute-class id ID #IMPLIED
>
825 <!ATTLIST attribute-extension id ID #IMPLIED
>
826 <!ATTLIST attribute-name id ID #IMPLIED
>
827 <!ATTLIST component id ID #IMPLIED
>
828 <!ATTLIST component-class id ID #IMPLIED
>
829 <!ATTLIST component-extension id ID #IMPLIED
>
830 <!ATTLIST component-family id ID #IMPLIED
>
831 <!ATTLIST component-type id ID #IMPLIED
>
832 <!ATTLIST converter id ID #IMPLIED
>
833 <!ATTLIST converter-class id ID #IMPLIED
>
834 <!ATTLIST converter-for-class id ID #IMPLIED
>
835 <!ATTLIST converter-id id ID #IMPLIED
>
836 <!ATTLIST default-locale id ID #IMPLIED
>
837 <!ATTLIST default-render-kit-id id ID #IMPLIED
>
838 <!ATTLIST default-value id ID #IMPLIED
>
839 <!ATTLIST description id ID #IMPLIED
>
840 <!ATTLIST display-name id ID #IMPLIED
>
841 <!ATTLIST faces-config id ID #IMPLIED
>
842 <!ATTLIST faces-context-factory id ID #IMPLIED
>
843 <!ATTLIST facet id ID #IMPLIED
>
844 <!ATTLIST facet-extension id ID #IMPLIED
>
845 <!ATTLIST facet-name id ID #IMPLIED
>
846 <!ATTLIST factory id ID #IMPLIED
>
847 <!ATTLIST from-action id ID #IMPLIED
>
848 <!ATTLIST from-outcome id ID #IMPLIED
>
849 <!ATTLIST from-view-id id ID #IMPLIED
>
850 <!ATTLIST icon id ID #IMPLIED
>
851 <!ATTLIST key id ID #IMPLIED
>
852 <!ATTLIST key-class id ID #IMPLIED
>
853 <!ATTLIST large-icon id ID #IMPLIED
>
854 <!ATTLIST lifecycle id ID #IMPLIED
>
855 <!ATTLIST lifecycle-factory id ID #IMPLIED
>
856 <!ATTLIST list-entries id ID #IMPLIED
>
857 <!ATTLIST locale-config id ID #IMPLIED
>
858 <!ATTLIST managed-bean id ID #IMPLIED
>
859 <!ATTLIST managed-bean-class id ID #IMPLIED
>
860 <!ATTLIST managed-bean-name id ID #IMPLIED
>
861 <!ATTLIST managed-bean-scope id ID #IMPLIED
>
862 <!ATTLIST managed-property id ID #IMPLIED
>
863 <!ATTLIST map-entries id ID #IMPLIED
>
864 <!ATTLIST map-entry id ID #IMPLIED
>
865 <!ATTLIST message-bundle id ID #IMPLIED
>
866 <!ATTLIST navigation-case id ID #IMPLIED
>
867 <!ATTLIST navigation-handler id ID #IMPLIED
>
868 <!ATTLIST navigation-rule id ID #IMPLIED
>
869 <!ATTLIST null-value id ID #IMPLIED
>
870 <!ATTLIST phase-listener id ID #IMPLIED
>
871 <!ATTLIST property id ID #IMPLIED
>
872 <!ATTLIST property-class id ID #IMPLIED
>
873 <!ATTLIST property-extension id ID #IMPLIED
>
874 <!ATTLIST property-name id ID #IMPLIED
>
875 <!ATTLIST property-resolver id ID #IMPLIED
>
876 <!ATTLIST redirect id ID #IMPLIED
>
877 <!ATTLIST referenced-bean id ID #IMPLIED
>
878 <!ATTLIST referenced-bean-class id ID #IMPLIED
>
879 <!ATTLIST referenced-bean-name id ID #IMPLIED
>
880 <!ATTLIST render-kit id ID #IMPLIED
>
881 <!ATTLIST render-kit-class id ID #IMPLIED
>
882 <!ATTLIST render-kit-factory id ID #IMPLIED
>
883 <!ATTLIST render-kit-id id ID #IMPLIED
>
884 <!ATTLIST renderer id ID #IMPLIED
>
885 <!ATTLIST renderer-class id ID #IMPLIED
>
886 <!ATTLIST renderer-extension id ID #IMPLIED
>
887 <!ATTLIST renderer-type id ID #IMPLIED
>
888 <!ATTLIST small-icon id ID #IMPLIED
>
889 <!ATTLIST state-manager id ID #IMPLIED
>
890 <!ATTLIST suggested-value id ID #IMPLIED
>
891 <!ATTLIST supported-locale id ID #IMPLIED
>
892 <!ATTLIST to-view-id id ID #IMPLIED
>
893 <!ATTLIST validator id ID #IMPLIED
>
894 <!ATTLIST validator-class id ID #IMPLIED
>
895 <!ATTLIST validator-id id ID #IMPLIED
>
896 <!ATTLIST value id ID #IMPLIED
>
897 <!ATTLIST value-class id ID #IMPLIED
>
898 <!ATTLIST variable-resolver id ID #IMPLIED
>
899 <!ATTLIST view-handler id ID #IMPLIED
>