All Classes and Interfaces

Class	Description
AbstractAnnotationValidator	Validation class that contains common logic to checks that specific annotations are not configured wrong.
AbstractAttachDetachEvent	Internal helper for AttachEvent and DetachEvent.
AbstractCompositeField<C extends Component,S extends AbstractCompositeField<C,S,T>,T>	An abstract field class that is backed by a composite component.
AbstractConfiguration	Defines a base contract for configuration (e.g.
AbstractConfigurationFactory	A configuration factory base logic which reads the token file.
AbstractDeploymentConfiguration	An abstract base class for DeploymentConfiguration implementations.
AbstractField<C extends AbstractField<C,T>,T>	An abstract implementation of a field, or a Component allowing user input.
AbstractField.ComponentValueChangeEvent<C extends Component,V>	Value change event fired by components.
AbstractFieldSupport<C extends Component & HasValue<AbstractField.ComponentValueChangeEvent<C,T>,T>,T>	Encapsulates all the logic required for a typical field implementation.
AbstractInjectableElementInitializer	Generic initializer logic.
AbstractListChange<T extends Serializable>	Change describing an operation (add/remove) in a list node feature.
AbstractLookupInitializer	SPI for customizing lookup in applications inside Servlet 5.0 containers.
AbstractNavigationStateRenderer	Base class for navigation handlers that target a navigation state.
AbstractNodeStateProvider	Abstract implementation of the ElementStateProvider related to the composition essence of the provider.
AbstractPropertyConfiguration	Provides a configuration based on string properties.
AbstractPropertyMap	Abstract class to be used as a parent for node maps which supports setting properties in a map.
AbstractRouteRegistry	AbstractRouteRegistry with locking support and configuration.
AbstractRouteRegistry.Configuration	Configuration interface to use for updating the configuration entity.
AbstractRouteRegistryInitializer	Common validation methods for route registry initializer.
AbstractRpcInvocationHandler	Abstract invocation handler implementation with common methods.
AbstractServerHandlers<T>	Abstract class for collecting Methods which are published as serverObject.<name> on the client side.
AbstractSinglePropertyField<C extends AbstractField<C,T>,T>	Abstract field that is based on a single element property.
AbstractStreamResource	Abstract stream resource class.
AbstractTaskClientGenerator	Abstract class for generating client files.
AbstractTextElementStateProvider	Abstract element state provider for text nodes.
AbstractTheme	Abstract theme definition class for defining theme variables when in use.
AccessAnnotationChecker	Checks if a given user has access to a given method.
AfterNavigationEvent	Event created after navigation completed.
AfterNavigationHandler	The base interface for every AfterNavigationEvent handler.
AfterNavigationListener	A listener that may be added to the UI using UI.addAfterNavigationListener(AfterNavigationListener).
AfterNavigationObserver	Any attached component implementing this interface will receive an event after all navigation tasks have resolved.
AllowInert	Makes a @ClientCallable method callable even if the UI is inert.
AmbiguousRouteConfigurationException	Exception indicating that the application's routes already has the navigation target with the given path.
AnnotationReader	Helper class for reading annotation data.
AnnotationValidator	Validation class that is run during servlet container initialization which checks that specific annotations are not configured wrong.
AnonymousAllowed	A security annotation, granting anonymous access to the Vaadin endpoint (or its method) it is placed onto.
ApplicationClassLoaderAccess	Allows to access the web application classloader.
ApplicationConfiguration	Configuration on the application level.
ApplicationConfigurationFactory	A factory for ApplicationConfiguration.
ApplicationConstants	A utility class providing static constants.
ApplicationRouteRegistry	Registry for holding navigation target components found on servlet initialization.
ApplicationRouteRegistry.ApplicationRouteRegistryWrapper	RouteRegistry wrapper class for storing the ApplicationRouteRegistry.
AppShellConfigurator	An interface to configure application features and the host page where the Vaadin application is running.
AppShellPredicate	Checks whether the provided class is an AppShellConfigurator eligible for the web application.
AppShellRegistry	The registry class for AppShellConfigurator annotations.
AppShellRegistry.AppShellRegistryWrapper	A wrapper class for storing the AppShellRegistry instance in the servlet context.
AppShellSettings	Initial page settings class for modifying the application shell.
ArchiveExtractionException	Exception indicating a failure during extraction of an archive file.
AtmospherePushConnection	A PushConnection implementation using the Atmosphere push support that is by default included in Vaadin.
AtmospherePushConnection.FragmentedMessage	Represents a message that can arrive as multiple fragments.
AtmospherePushConnection.State
AttachEvent	Event fired after a Component is attached to the UI.
AttachExistingElementFeature	Temporary storage of data required to handle existing element attachment callback from the client side.
AttachExistingElementRpcHandler	RPC handler for a client-side response on attach existing element request.
AttachNotifier	Mixin interface for components that support adding attach listeners.
AttachTemplateChildRpcHandler	RPC handler for a client-side response on attach existing element by id request.
Attributes	The Attributes class represents a set of attributes.
BasicElementStateProvider	Implementation which stores data for basic elements, i.e.
BasicElementStyle	Implementation of Style for BasicElementStateProvider.
BasicTextElementStateProvider	Handles storing and retrieval of the state information for a text node using a state node.
BasicTypeValue	The feature contains a value of the basic type.
BeanUtil	Utility class for Java Beans information access.
BeforeEnterEvent	Event created before navigation happens.
BeforeEnterHandler	The base interface for every BeforeEnterEvent handler.
BeforeEnterListener	A listener that may be added to the UI using UI.addBeforeEnterListener(BeforeEnterListener).
BeforeEnterObserver	Any attached component implementing this interface will receive an event before a new navigation state is entered.
BeforeEvent	Abstract before event class that has the common functionalities for BeforeLeaveEvent and BeforeEnterEvent.
BeforeLeaveEvent	Event created before navigation happens.
BeforeLeaveHandler	The base interface for every BeforeLeaveEvent handler.
BeforeLeaveListener	A listener that may be added to the UI using UI.addBeforeLeaveListener(BeforeLeaveListener).
BeforeLeaveObserver	Any attached component implementing this interface will receive an event before leaving the current navigation state.
BlurNotifier<T extends Component>	Mixin interface to handle blur events on components.
BlurNotifier.BlurEvent<C extends Component>	Represents the DOM event "blur".
BodySize	Defines the body size that will be added to the HTML of the host pages.
BootstrapException	A Vaadin internal runtime exception thrown when the writing of the bootstrap page in BootstrapHandler fails for some reason.
BootstrapHandler	Request handler which handles bootstrapping of the application, i.e.
BootstrapHandler.BootstrapContext	Provides context information for the bootstrap process.
BootstrapHandler.BootstrapPageBuilder	Builds bootstrap pages.
BootstrapHandler.BootstrapUriResolver	The URI resolver used in the bootstrap process.
BootstrapHandler.PageBuilder	Interface for objects capable of building the bootstrap page.
BootstrapHandlerHelper	Helper methods for use in bootstrapping.
BootstrapInitialPredicate	The callback used by bootstrap handlers in order to know when a request needs to pre-render the UI and include the initial UIDL in the page.
BootstrapUrlPredicate	The callback used by bootstrap handlers in order to know when a request is a valid URL to render the page.
BrowserDetails	Parses the user agent string from the browser and provides information about the browser.
BrowserDetails.OperatingSystem	Detected operating systems.
BrowserLiveReload	Provides a way to reload browser tabs via web socket connection passed as a AtmosphereResource.
BrowserLiveReload.Backend	Live reload enabling technology detected.
BrowserLiveReloadAccess	Deprecated. Use BrowserLiveReloadAccessor instead
BrowserLiveReloadAccessor	Provides API to access to the BrowserLiveReload instance by a VaadinService.
BrowserWindowResizeEvent	Event that is fired when a browser window containing a uI is resized.
BrowserWindowResizeListener	Listener that gets notified when the size of the browser window containing the uI has changed.
CaseUtil	Utilities related to various case operations.
ChildElementConsumer	Callback which allows to handle request to map a client side DOM element to the server Element instance.
ClassAttributeHandler	Emulates the class attribute by delegating to Element.getClassList().
ClassFinder	Interface for annotated and subclass class searches.
ClassFinder.CachedClassFinder	Implementation that proxy and cache a real ClassFinder.
ClassFinder.DefaultClassFinder	Implementation that searches for annotated classes or subclasses in a list of classes.
ClassList	Representation of the class names for an Element.
ClassLoaderAwareServletContainerInitializer	Allows to load the implementation class by one classloader but accepts classes in ClassLoaderAwareServletContainerInitializer.onStartup(Set, ServletContext) method loaded by another classloader.
ClickEvent<C extends Component>	Event fired when a component is clicked.
ClickNotifier<T extends Component>	Mixin interface for components that support adding click listeners to the their root elements.
ClientCallable	Publishes the annotated method so it can be invoked from the client side using the notation this.$server.method().
ClientCallableHandlers	Methods which are published as element.$server.<name> on the client side.
Command	A generic command interface meant to be used for passing lambdas around.
Component	A Component is a higher level abstraction of an Element or a hierarchy of Elements.
ComponentEvent<T extends Component>	An event whose source is a Component.
ComponentEventBus	An event bus for Components.
ComponentEventBusUtil	Static helpers and caching functionality for ComponentEventBus.
ComponentEventListener<T extends ComponentEvent<?>>	Generic listener for component events.
ComponentMapping	A server side only node feature for mapping a node to a component.
ComponentMetaData	Immutable meta data related to a component class.
ComponentMetaData.DependencyInfo	Dependencies defined for a Component class.
ComponentMetaData.SynchronizedPropertyInfo	Synchronized properties defined for a Component class.
ComponentTracker	Tracks the location in source code where components were instantiated.
ComponentTracker.Location	Represents a location in the source code.
ComponentUtil	Utility methods for Component.
Composite<T extends Component>	A composite encapsulates a Component tree to allow creation of new components by composing existing components.
CompositionEndEvent	The event when a composition is ended.
CompositionEvent	Abstract class for composition events.
CompositionNotifier	Mixin interface for components that support adding composition listeners to the their root elements.
CompositionStartEvent	The event when a composition is started.
CompositionUpdateEvent	The event when a composition is updated.
ConfiguredRoutes	Route configuration class that is used as a value object.
ConfigureRoutes	Configuration class for editing routes.
ConstantPool	Keeps track of ConstantPoolKey values that have already been sent to the client.
ConstantPoolKey	Wraps a JSON value that should be stored in the ConstantPool shared between the client and the server.
Constants	Constants used by the server side framework.
ContentTypeResolver	Content type resolver.
CssData	A container for CssImport information when scanning the class path.
CssImport	Imports a CSS file into the application bundle.
CssImport.Container	Internal annotation to enable use of multiple CssImport annotations.
CurrentInstance	Keeps track of various current instances for the current thread.
CustomAttribute	Callback for handling attributes with special semantics.
CustomElementNameValidator	Validates custom-element name according to definition in Custom element name
CustomizedSystemMessages	Contains the system messages used to notify the user about various critical situations that can occur.
CvdlProducts	Utilities for commercial product handling.
DeadlockDetectingCompletableFuture<T>	A completable future that will throw from blocking operations if the current thread holds the session lock.
DebouncePhase	Defines phases for an event that is debounced.
DebounceSettings	Debounce settings for declaratively defined client-side event handlers.
DefaultApplicationConfigurationFactory	Default implementation of ApplicationConfigurationFactory.
DefaultApplicationConfigurationFactory.ApplicationConfigurationImpl
DefaultArchiveExtractor	Default implementation for file archive extraction.
DefaultDeploymentConfiguration	The default implementation of DeploymentConfiguration based on a base class for resolving system properties and a set of init parameters.
DefaultErrorHandler	Marks an HasErrorParameter view as Framework default handler so it can be disregarded if there is a custom view for the same Exception.
DefaultErrorHandler	The default implementation of ErrorHandler.
DefaultFileDownloader	Default file downloader implementation.
DefaultInstantiator	Default instantiator that is used if no other instantiator has been registered.
DefaultRoutePathProvider	Default implementation for RoutePathProvider.
DefaultRouteResolver	Default implementation of the RouteResolver interface.
DefaultRpcDecoder	Decodes the standard basic types from their JSON representation.
DefaultSystemMessagesProvider	System messages provider using the built-in default system messages.
Dependency	Represents an html import, stylesheet or JavaScript to include on the page.
Dependency.Type	The type of a dependency.
DependencyFilter	Filter for dependencies loaded using @StyleSheet, and * @JavaScript.
DependencyList	List for storing dependencies/files (JavaScript, Stylesheets) to be loaded and included on the client side.
DependencyTreeCache<T>	A caching tree traverser for collecting and parsing dependencies.
DeploymentConfiguration	A collection of properties configured at deploy time as well as a way of accessing third party properties not explicitly supported by this class.
DeploymentConfigurationFactory	Creates DeploymentConfiguration filled with all parameters specified by the framework users.
DeprecatedPolymerPublishedEventHandler	Deprecated. Polymer template support is deprecated - we recommend you to use LitTemplate instead.
DeprecatedPolymerTemplate	Deprecated. Polymer template support is deprecated - we recommend you to use LitTemplate instead.
DetachEvent	Event fired before a Component is detached from the UI.
DetachNotifier	Mixin interface for components that support adding detach listeners.
DevModeHandler
DevModeHandlerManager	Provides API to access to the DevModeHandler instance by a VaadinService.
Direction	Specifies the direction of the text and other content inside of an element.
DisabledUpdateMode	Controls RPC communication from the client side to the server side respecting enabled state.
DomEvent	Maps a DOM event to a ComponentEvent.
DomEvent	Server-side representation of a DOM event fired in the browser.
DomEventListener	Server-side listener for client-side DOM events.
DomListenerRegistration	A registration for configuring or removing a DOM event listener added to an element.
DuplicateNavigationTitleException	Exception indicating a conflict between a route target implementing HasDynamicTitle while also having a PageTitle annotation.
Element	Represents an element in the DOM.
ElementAttachEvent	Event fired after an Element has been attached to the UI.
ElementAttachListener	Listener for element attach events.
ElementAttributeMap	Map for element attribute values.
ElementChildrenList	List of nodes describing the child elements of an element.
ElementClassList	Handles CSS class names for an element.
ElementConstants	Constants for common element attribute, property, style names.
ElementData	Map of basic element information.
ElementDetachEvent	Event fired after an element has been detached from the UI.
ElementDetachListener	Listener for element detach events.
ElementFactory	Helpers to create Element instances.
ElementListenerMap	Map of DOM events with server-side listeners.
ElementPropertyMap	Map for element property values.
ElementStateProvider	Handles storing and retrieval of the state information for an element using a state node.
ElementStylePropertyMap	Map for element style values.
ElementUtil	Provides utility methods for Element.
EmptyChange	Empty change for the feature to report its presence for the client (send the feature information even though its data is empty).
EncodeUtil	Utilities related to various encoding schemes.
EndPointData	A simple container with the information related to an application end-point, i.e.
EndpointGeneratorTaskFactory	A factory for creating Vaadin Endpoint generator tasks.
EndpointRequestUtil	A container for utility methods related with Hilla endpoints.
ErrorEvent	An error thrown by the framework and handled by an ErrorHandler.
ErrorHandler	Application errors handler.
ErrorHandlingCommand	Defines the interface to handle exceptions thrown during the execution of a FutureAccess.
ErrorNavigationEvent	Event object with data related to error navigation.
ErrorNavigationTargetInitializer	Servlet initializer for collecting all available error handler navigation targets implementing HasErrorParameter on startup.
ErrorParameter<T extends Exception>	Navigation error parameter class containing thrown exception and possibly a custom message.
ErrorRouteRegistry	Interface class for RouteRegistries that can be used to request for error navigation views for Exceptions.
ErrorStateRenderer	Handles error navigation rendering in the target UI.
ErrorTargetEntry	A pair of a navigation target for handling exceptions and the exception type handled by the navigation target.
EventData	Maps data from a DOM event to a ComponentEvent.
EventDataCache	Cache for tracking global information related to ComponentEvent types.
EventOptions	EventOptions is used to configure the custom event published by an exported web component.
EventRpcHandler	RPC handler for events.
EventUtil	Event handling utilities.
ExecutionContext	Context of a callback execution when UI.beforeClientResponse(com.vaadin.flow.component.Component, com.vaadin.flow.function.SerializableConsumer) is invoked.
ExecutionFailedException	Thrown by FallibleCommand if it's unable to complete its execution.
ExtendedClientDetails	Provides extended information about the web browser, such as screen resolution and time zone.
FallbackChunk	Fall back chunk info.
FallbackChunk.CssImportData	Css data stored in fallback chunk.
FallibleCommand	A generic command which may fail.
FaviconHandler	Handles the favicon request explicitly and return 404 for it.
Feature	Information about a feature available behind a flag.
FeatureFlags	Tracks available feature flags and their status.
FeatureFlags.FeatureFlagsWrapper	FeatureFlags wrapper class for storing the FeatureFlags object.
FileIOUtils
Focusable<T extends Component>	Represents a component that can gain and lose focus.
FocusNotifier<T extends Component>	Mixin interface to handle focus events on components.
FocusNotifier.FocusEvent<C extends Component>	Represents the DOM event "focus".
FrontendDependencies	Represents the class dependency tree of the application.
FrontendDependenciesScanner	Frontend dependencies scanner.
FrontendDependenciesScanner.FrontendDependenciesScannerFactory	Frontend dependencies scanner factory.
FrontendTools	Provides access to frontend tools (Node.js and npm, pnpm) and optionally installs the tools if needed.
FrontendToolsLocator	Helps to locate the tools in the system by their names.
FrontendToolsSettings	Configuration object for controlling the FrontendTools features.
FrontendUtils	A class for static methods and definitions that might be used in different locations.
FrontendUtils.CommandExecutionException	Thrown when the command execution fails.
FrontendUtils.UnknownVersionException	Thrown when detecting the version of a tool fails.
FrontendVersion	Version object for frontend versions comparison and handling.
FrontendWebComponentGenerator	Generates embeddable web component files in npm mode, hiding the complexity caused by using a different class loader.
FutureAccess	Encapsulates a Command submitted using VaadinSession.access(Command).
GenerateMainImports	Collect generated-flow-imports content for project to use to determine if dev-bundle contains all required imports.
GwtIncompatible	Marks a type, method, constructor of field to be ignored by the GWT compiler.
HandlerHelper	Contains helper methods for VaadinServlet and generally for handling VaadinRequests.
HandlerHelper.RequestType	Framework internal enum for tracking the type of a request.
HasAriaLabel	A generic interface for components and other user interface objects that may have an aria-label property to set the accessible name of the component.
HasComponents	A component to which the user can add and remove child components.
HasDynamicTitle	Allows to resolve navigation target title dynamically at runtime.
HasElement	Marker interface for any class which is based on an Element.
HasEnabled	A generic interface for components and other user interface objects that may be enabled or disabled.
HasErrorParameter<T extends Exception>	Defines a view that handles the exceptions for the set Exception type T.
HasHelper	Mixin interface for field components that have helper text as property and slots for inserting components.
HasLabel	A component that supports label definition.
HasOrderedComponents	A component which the children components are ordered, so the index of each child matters for the layout.
HasSize	Any component implementing this interface supports setting the size of the component using HasSize.setWidth(String) and HasSize.setHeight(String).
HasStyle	Represents Component which has class attribute and inline styles.
HasText	A component that supports text content.
HasText.WhiteSpace	Represents "white-space" style values.
HasTheme	Represents Component which has theme attribute.
HasUrlParameter<T>	Defines route parameters for navigation targets for use in routing.
HasUrlParameterFormat	Utility methods to transform urls and parameters from/into the HasUrlParameter format into/from the template format.
HasValidation	A component that supports input validation.
HasValue<E extends HasValue.ValueChangeEvent<V>,V>	A generic interface for field components and other user interface objects that have a user-editable value.
HasValue.ValueChangeEvent<V>	An event fired when the value of a HasValue changes.
HasValue.ValueChangeListener<E extends HasValue.ValueChangeEvent<?>>	A listener for value change events.
HasValueAndElement<E extends HasValue.ValueChangeEvent<V>,V>	A component that has a value.
HeartbeatEvent	Event created for an application heartbeat from the client.
HeartbeatHandler	Handles heartbeat requests.
HeartbeatListener	Listener for listening to the heartbeat of the application.
HighlightAction<T>	An action to be performed to set the highlight state of the target.
HighlightActions	A set of predefined HighlightActions.
HighlightCondition<T>	A condition to meet to determine the highlight state of the target.
HighlightConditions	A set of predefined HighlightConditions.
History	Represents window.history in the browser.
History.HistoryStateChangeEvent	Event fired when the history state has changed.
History.HistoryStateChangeHandler	Handles location change events.
Html	A component which encapsulates a given HTML fragment with a single root element.
HtmlComponent	Base class for a Component that represents a single built-in HTML element.
HtmlContainer	Base class for a Component that represents a single built-in HTML element that can contain child components or text.
HtmlUtils	Helpers for HTML related aspects.
HttpStatusCode	HTTP status codes as defined in RFC 2068.
I18NProvider	I18N provider interface for internationalization usage.
Id	Defines the id of a component or an element to map to inside a lit template.
IdCollector	Collects information of @Id mapped fields in a template class.
IdMapper	Creates or maps Element instances to fields mapped using @Id.
ImmutableClassList	Immutable class list implementation.
ImmutableEmptyStyle	A style implementation which is empty and immutable.
IndexHtmlRequestHandler	This class is responsible for serving the index.html according to the template provided in the frontend folder.
IndexHtmlRequestListener	This event listener is notified when the Single Page Application's HTML page is about to be generated and sent to the client.
IndexHtmlResponse	This represents the state of a Index HTML response being generated.
InertData	Server-side feature defining whether a node is inert, and if it should ignore inheriting inert state from parent.
InitParameters	Constants for all servlet init parameters.
InjectableFieldConsumer	Three argument consumer.
Inline	Defines files to inline into the initial page.
Inline.Container	Internal annotation to enable use of multiple Inline annotations.
Inline.Position	Inline position enum.
Inline.Wrapping	File content wrapping enum.
InlineTargets	Data holder class for collected Inline annotations to be added to the initial page.
InputEvent	Event fired when the component has received any type of input (e.g.
InputNotifier	Mixin interface for components that support adding input listeners to the their root elements.
InputStreamFactory	Creates input stream instances that provides the actual data of a StreamResource.
InstallationException	Exception indicating a failure during installation of node and npm.
Instantiator	Delegate for discovering, creating and managing instances of various types used by Flow.
InstantiatorFactory	A factory for an Instantiator.
InternalRedirectHandler	Handles navigation by redirecting the user to some location in the application.
InternalServerError	This is a basic default error view shown on exceptions during navigation.
InvalidApplicationConfigurationException	Exception indicating that the application's routes have been configured incorrectly.
InvalidCustomElementNameException	Exception indicating that the custom-element name is invalid.
InvalidI18NConfigurationException	Exception indicating that the application's I18N localization has been configured incorrectly.
InvalidLocationException	Thrown to indicate that a Location instance is invalid.
InvalidRouteConfigurationException	Exception indicating that the application's routes have been configured incorrectly.
InvalidRouteLayoutConfigurationException	Exception indicating that Route layouts configuration has problems.
ItemLabelGenerator<T>	ItemLabelGenerator can be used to customize the string shown to the user for an item.
JarContentsManager	Shared code for managing contents of jar files.
JavaScript	Defines JavaScript dependencies on a Component class.
JavaScript.Container	Internal annotation to enable use of multiple JavaScript annotations.
JavaScriptBootstrapHandler	Processes a 'start' request type from the client to initialize server session and UI.
JavaScriptBootstrapHandler.JavaScriptBootstrapContext	Custom BootstrapContext for JavaScriptBootstrapHandler.
JavaScriptNavigationStateRenderer	Handle navigation events in relation to the client side bootstrap UI.
JavaScriptSemantics	Helpers for replicating JavaScript semantics in Java.
JsModule	Annotation for defining JavaScript Module dependencies on a Component class.
JsModule.Container	Internal annotation to enable use of multiple JsModule annotations.
JsonCodec	Utility for encoding objects to and from JSON.
JsonConstants	A utility class providing constants for JSON related features.
JsonSerializable	Base interface for classes that are serializable to and from JsonObject.
JsonSerializer	General-purpose serializer of Java objects to JsonValue and deserializer of JsonValue to Java objects.
JsonUtils	Helpers for using elemental.json.
JSR356WebsocketInitializer	Initializer class for JSR 356 websockets.
JSR356WebsocketInitializer.FakeServletConfig	"ServletConfig" which only provides information from a ServletRegistration and its ServletContext.
Key	An interface to represent keyboard keys.
KeyboardEvent	Abstract class for keyboard events.
KeyDownEvent	The event when a key is pressed.
KeyEventListener<E extends KeyboardEvent>	A conditional event listener for KeyboardEvents.
KeyLocation	Possible keyboard key locations.
KeyModifier	Modifier keys.
KeyNotifier	Mixin interface for components that support adding key event listeners to the their root elements.
KeyPressEvent	The event when a key is pressed.
KeyUpEvent	The event when a key is released.
ListAddChange<T extends Serializable>	Change describing an add operation in a list node feature.
ListClearChange<T extends Serializable>	Change describing a clear operation in a list node feature.
ListenerPriority	This annotation sets the priority of execution on BeforeEnterListeners, BeforeLeaveListeners and AfterNavigationListeners.
ListRemoveChange<T extends Serializable>	Change describing a remove operation in a list node feature.
LoadingIndicatorConfiguration	Provides method for configuring the loading indicator.
LoadingIndicatorConfigurationMap	Map for storing configuration for the loading indicator.
LoadMode	Determines a way that dependency is loaded.
LocaleChangeEvent	Event object with data related to locale change.
LocaleChangeObserver	Any com.vaadin.ui.Component implementing this interface will be informed when the UI locale is changed and on attach.
LocaleUtil	Utility class for locale handling.
Location	Represents a relative URL made up of path segments and query parameters, but lacking e.g.
LocationChangeEvent	Event created when the location changes by any of the reasons defined at NavigationTrigger.
LocationUtil	Utility class exposing reusable utility methods for location.
LongPollingCacheFilter	A PerRequestBroadcastFilter implementation that handles AtmospherePushConnection.PushMessages to ensure that a message is preserved in the BroadcasterCache until the client has received it.
Lookup	Provides a way to discover services used by Flow (SPI).
LookupInitializer	Default implementation of AbstractLookupInitializer.
LookupInitializer.AppShellPredicateImpl	Default implementation of AppShellPredicate.
LookupInitializer.LookupImpl	Default implementation of Lookup.
LookupInitializer.ResourceProviderImpl	Default implementation of ResourceProvider.
LookupServletContainerInitializer	Standard servlet initializer for collecting all SPI implementations.
MapPutChange	Change describing a changed value in a map feature.
MapRemoveChange	Change describing a value removed from a map.
MapSyncRpcHandler	Model map synchronization RPC handler.
MessageDigestUtil	Utility class for common MessageDigest operations.
Meta	Defines a meta tag with customized name and content that will be added to the HTML of the host page of a UI class.
Meta.Container	Internal annotation to enable use of multiple Meta annotations.
MetadataWriter	Serializes miscellaneous metadata to JSON.
Mode	The mode the application is running in.
ModelList	List for model values used in data binding in templates.
NavigationEvent	Event object with data related to navigation.
NavigationHandler	Handles navigation to a location e.g.
NavigationRouteTarget	Contains the information resulted from searching a route target using a navigation url as input.
NavigationRpcHandler	RPC handler for Navigation.
NavigationState	Contains all relevant information related to a valid navigation.
NavigationStateBuilder	A builder class for constructing new NavigationState instances.
NavigationStateRenderer	Handles navigation events by rendering a contained NavigationState in the target UI.
NavigationTargetFilter	A filter that can prevent specific navigation targets from being registered.
NavigationTrigger	The type of user action that triggered navigation.
NetworkUtil	Utility class for network related methods.
Node<N extends Node<N>>	Represents a node in the DOM.
NodeAttachChange	Change describing that a node has been attached.
NodeChange	Base class describing a change to a state node.
NodeDetachChange	Change describing that a node has been detached.
NodeFeature	A node feature represents a group of related values and functionality in a state node.
NodeFeatureChange	Base class for all node changes related to a feature.
NodeFeatureRegistry	A registry of node features that are available based on type.
NodeFeatures	Registry of node feature id numbers and map keys shared between server and client.
NodeInstaller	Node installation class.
NodeList<T extends Serializable>	A state node feature that structures data as a list.
NodeList.SetView<T extends Serializable>	Provides access to a NodeList as a Set.
NodeMap	A state node feature that structures data as a map.
NodeOwner	Abstract root of a state node tree.
NodeProperties	Various node properties' ids.
NodeTasks	An executor that it's run when the servlet context is initialised in dev-mode or when flow-maven-plugin goals are run.
NodeUpdater	Base abstract class for frontend updaters that needs to be run when in dev-mode or from the flow maven plugin.
NodeValue<T extends Serializable>	A node feature that carries a single value.
NodeVisitor	Element API node visitor interface.
NodeVisitor.ElementType	The type of the element.
NoInputStreamException	Exception for when there is no InputStream available.
NoOutputStreamException	Exception for when there is no OutputStream available.
NotFoundException	Exception indicating that something went wrong while resolving navigation routes.
NoTheme	A marker annotation to avoid applying any default theme to the application.
NotSupported	Methods annotated with NotSupported are mapped to the original webcomponent implementation, but not supported at Java level.
NpmPackage	Annotation for defining an npm package dependency on a Component class which includes one or more JS modules.
NpmPackage.Container	Internal annotation to enable use of multiple NpmPackage annotations.
NullOwner	A stateless singleton node owner that is used for nodes that have not yet been attached to a state tree.
OneTimeInitializerPredicate	The presence of the service implementing this interface with OneTimeInitializerPredicate.runOnce() returning true means that ServletContainerInitializers are executed only once and the implementation doesn't have to care about cleaning up data collected based on previous call.
OptionalParameter	Marks a Navigation url parameter as optional.
Options	Build a NodeExecutor instance.
Page	Represents the web page open in the browser, containing the UI it is connected to.
Page.ExtendedClientDetailsReceiver	Callback for receiving extended client-side details.
PageTitle	Defines the HTML page title for a navigation target.
Pair<U extends Serializable,V extends Serializable>	Generic class representing an immutable pair of values.
ParameterDeserializer	Parameter deserialization utility.
ParentLayout	Defines the parent layout for components in routing hierarchy.
ParserData	Immutable parser data which may be stored in cache.
PathUtil	Utility class which contains various methods for parsing a route url into segments.
PendingJavaScriptInvocation	A pending JavaScript result that can be sent to the client.
PendingJavaScriptResult	A pending result from a JavaScript snippet sent to the browser for evaluation.
PendingJavaScriptResult.JavaScriptException	Exception used when a CompletableFuture returned from PendingJavaScriptResult is completed exceptionally because of a client-side error.
Platform	Platform contains information about system architecture and OS.
Platform	Provides information about the current version of Vaadin Platform.
PollConfigurationMap	A node map for storing configuration for polling.
PollEvent	An event that is fired whenever a client polls the server for asynchronous UI updates.
PollNotifier	The interface for adding and removing PollEvent listeners.
PolymerEventListenerMap	Map of PolymerTemplate events with server-side listeners.
PolymerServerEventHandlers	Deprecated. Polymer template support is deprecated - we recommend you to use LitTemplate instead.
Postpone	Container class for containing left over listeners on postponed navigation.
PreserveOnRefresh	Indicates that a previous view instance should be-reused when reloading a location in the same browser window/tab.
PropertyChangeDeniedException	The exception is thrown when a property change from client is disallowed on the server side.
PropertyChangeEvent	An event fired when the value of a property changes.
PropertyChangeListener	A listener for property change events.
PropertyConfiguration<C extends Component,P extends Serializable>	Offers a fluent API for configuring the properties of embedded web components produced by WebComponentExporter.
PropertyConfigurationImpl<C extends Component,P extends Serializable>	For internal use only.
PropertyData<P extends Serializable>	Value object containing information of a web component's property field.
PropertyDeploymentConfiguration	The property handling implementation of DeploymentConfiguration based on a base class for resolving system properties and a set of init parameters.
PropertyDescriptor<S,G>	Describes a component property that has its value stored in some form in the component's element, typically an element property or attribute.
PropertyDescriptors	Factory methods for creating PropertyDescriptor instances.
ProxyConfig	Proxy configuration used for downloads and executions.
ProxyConfig.Proxy	Class for holding proxy information.
PublishedServerEventHandlerRpcHandler	RPC handler for events triggered through element.$server or simply $server in template event handlers.
Push	Configures automatic server push.
PushAtmosphereHandler	Handles Atmosphere requests and forwards them to logical methods in PushHandler.
PushConfiguration	Provides method for configuring the push channel.
PushConfigurationMap	Map for storing the push configuration for a UI.
PushConfigurationMap.PushConfigurationParametersMap	Map for storing push parameters.
PushConnection	Represents a bidirectional ("push") connection between a single UI and its client-side.
PushConnectionFactory	Factory that produces instances of PushConnection.
PushConstants	Shared constants used by push.
PushHandler	Handles incoming push connections and messages and dispatches them to the correct UI/ AtmospherePushConnection.
PushMode	The mode of bidirectional ("push") communication that is in use.
PushRequestHandler	Handles requests to open a push (bidirectional) communication channel between the client and the server.
PWA	Defines application PWA properties.
PwaConfiguration	Holds the configuration from the PWA annotation.
PwaHandler	Handles serving of PWA resources.
PwaIcon	Implementation of icons used in PWA resources.
PwaIcon.Domain	Place where icon belongs to (header or manifest.webmanifest).
PwaRegistry	Registry for PWA data.
QueryParameters	Holds query parameters information.
Range	An immutable representation of a range, marked by start and end points.
ReconnectDialogConfiguration	Provides methods for configuring the reconnect dialog.
ReconnectDialogConfigurationMap	Map for storing the reconnect dialog configuration for a UI.
ReflectionCache<C,T>	A thread-safe cache for the result of doing some reflection lookup based on a class.
ReflectTools	An util class with helpers for reflection operations.
Registration	A registration object for removing an event listener added to a source.
RequestHandler	Handler for producing a response to HTTP requests.
ResolveRequest	An object used to encapsulate data used in resolving routing requests.
ResourceProvider	Static "classpath" resources provider.
ResponseWriter	The class that handles writing the response data into the response.
ReturnChannelHandler	RPC handler for return channel messages.
ReturnChannelMap	Server-side node feature that keeps track of the return channels registered for a state node.
ReturnChannelRegistration	A registration for a return channel.
Route	Defines the route template suffix for components that function as navigation targets in routing.
RouteAlias	Defines the route alias for components that function as navigation targets in routing.
RouteAlias.Container	Internal annotation to enable use of multiple RouteAlias annotations.
RouteAliasData	Route data for an 'alias' route.
RouteBaseData<T extends RouteBaseData>	Abstract base class for route and route alias data.
RouteConfiguration	Route configuration helper class for adding, removing and reading routes from the different registries.
RouteData	Data collection of information for a specific registered route target.
RouteNotFoundError	This is a basic default error view shown on routing exceptions.
RouteParam	Route parameter containing the name and the value used mainly when constructing a RouteParameters instance.
RouteParameterData	Immutable data representing one url parameter.
RouteParameterFormatOption	Define the route parameters format flags.
RouteParameterRegex	Predefined regex used with template parameters.
RouteParameters	Immutable container which stores the route parameters extracted from a navigation url received from the client.
RoutePathProvider	Allows to implement a custom navigation target path generation logic for components annotated with @Route(Route.NAMING_CONVENTION).
RoutePrefix	Defines the route prefix that a Parent layout adds to a route when used in the active view chain.
Router	The router takes care of serving content when the user navigates within a site or an application.
RouteRegistry	The RouteRegistry interface class that gives the out facing usage needs for a route registry implementation.
RouteRegistryInitializer	Servlet initializer for collecting all available Routes on startup.
RouteResolver	Callback interface for resolving ResolveRequests to new NavigationStates.
RouterLayout	Implementations of this interface represent a parent for a navigation target components via the Route.layout() parameter.
RouterLink	A link that handles navigation internally using Router instead of loading a new page in the browser.
RoutesChangedEvent	Result class containing the removed and added routes for the latest configuration.
RoutesChangedListener	Listener that gets notified when the registered routes for a RouteRegistry are changed in some way.
RouteTarget	Route target stores the target component and parent layouts.
RouteUtil	Utility class with methods for route handling.
RpcDecodeException	Thrown if RPC method argument cannot be decoded to the required type.
RpcDecoder	Decoder of RPC method arguments (server-side methods invoked from the client-side).
RpcInvocationHandler	RPC invocation handler interface.
ScrollOptions	Options for scrollIntoView.
ScrollOptions.Alignment	Alignment for scrollIntoView.
ScrollOptions.Behavior	Scroll behavior for scrollIntoView.
SerializableBiConsumer<T,U>	A BiConsumer that is also Serializable.
SerializableBiFunction<T,U,R>	A BiFunction that is also Serializable.
SerializableBiPredicate<T,U>	A BiPredicate that is also Serializable.
SerializableComparator<T>	A Comparator that is also Serializable.
SerializableConsumer<T>	A Consumer that is also Serializable.
SerializableEventListener	Event listener interface that is serializable.
SerializableFunction<T,R>	A Function that is also Serializable.
SerializableNodeList<T extends Serializable>	A list which contains Serializable values but not StateNodes.
SerializablePredicate<T>	A Predicate that is also Serializable.
SerializableRunnable	A Runnable that is also Serializable.
SerializableSupplier<T>	A Supplier that is also Serializable.
SerializableTriConsumer<T,U,V>	Like SerializableBiConsumer, but with three arguments.
ServerRpcHandler	Handles a client-to-server message containing serialized RPC invocations.
ServerRpcHandler.InvalidUIDLSecurityKeyException	Exception thrown then the security key sent by the client does not match the expected one.
ServerRpcHandler.ResynchronizationRequiredException	Exception thrown then the client side resynchronization is required.
ServerRpcHandler.RpcRequest	A data transfer object representing an RPC request sent by the client side.
ServerSideFeature	Abstract node feature that is only present on the server.
ServiceContextUriResolver	A URI resolver which resolves paths for loading through VaadinService resource methods.
ServiceDestroyEvent	Event fired to ServiceDestroyListener when a VaadinService is being destroyed.
ServiceDestroyListener	Listener that gets notified when the VaadinService to which it has been registered is destroyed.
ServiceException	Thrown for problems which occur in the VaadinService layer.
ServiceInitEvent	Event fired to VaadinServiceInitListener when a VaadinService is being initialized.
ServletContextListeners	All ServletContextListeners in Flow merged into one actual listener to be able to control the order they are executed in.
ServletDeployer	Context listener that automatically registers Vaadin servlets.
SessionDestroyEvent	Event fired when a Vaadin service session is no longer in use.
SessionDestroyListener	A listener that gets notified when a Vaadin service session is no longer used.
SessionExpiredException	Exception indicating that the session has expired.
SessionExpiredHandler	A specialized RequestHandler which is capable of sending session expiration messages to the user.
SessionInitEvent	Event gets fired when a new Vaadin service session is initialized for a Vaadin service.
SessionInitListener	Event listener that can be registered to a VaadinService to get an event when a new Vaadin service session is initialized for that service.
SessionRequestHandler	Handles a request by passing it to each registered RequestHandler in the session in turn until one produces a response.
SessionRouteRegistry	SessionRouteRegistry is a mutable route registry that is valid in the scope of VaadinSession.
ShadowRoot	Represents a shadow dom root of an element.
ShadowRootData	Map of basic element information.
ShadowRootHost	Marker feature for a StateNode which is a shadow root for some element.
ShadowRootStateProvider	Implementation which handles shadow root nodes.
SharedUtil	Misc internal utility methods used by both the server and the client package.
ShortcutEvent	Event when shortcut is detected.
ShortcutEventListener	Listener for shortcut events.
ShortcutRegistration	A registration object for both configuring and removing the registered keyboard shortcut.
Shortcuts	Collections of methods for configuring more complex Shortcut interactions.
SpringCsrfToken	A pojo for Spring CSRF token.
SpringCsrfTokenUtil	A util class for helping dealing with Spring CSRF token.
StateNode	A node in the state tree that is synchronized with the client-side.
StateNodeNodeList	A list which contains StateNodes.
StateTree	The state tree that is synchronized with the client-side.
StateTree.BeforeClientResponseEntry	A task to be executed before the client response, together with an execution sequence number and context object.
StateTree.ExecutionRegistration	A registration object for removing a task registered for execution before the client response.
StaticFileHandler	Handler for static files.
StaticFileHandlerFactory	A factory to create a StaticFileHandler.
StaticFileServer	Handles sending of resources from the WAR root (web content) or META-INF/resources in the case that VaadinServlet is mapped using "/*".
StreamingEndEventImpl	Implementation of StreamVariable.StreamingEndEvent.
StreamingErrorEventImpl	Implementation for StreamVariable.StreamingErrorEvent.
StreamingProgressEventImpl	Implementation for StreamVariable.StreamingProgressEvent.
StreamingStartEventImpl	Implementation for StreamVariable.StreamingStartEvent.
StreamReceiver	Represents a receiver for data upload from the client.
StreamReceiverHandler	Handles StreamReceiver instances registered in VaadinSession.
StreamReceiverHandler.UploadInterruptedException	An UploadInterruptedException will be thrown by an ongoing upload if StreamVariable.isInterrupted() returns true.
StreamRegistration	Stream registration result.
StreamRequestHandler	Handles StreamResource and StreamReceiver instances registered in VaadinSession.
StreamResource	Represents dynamically generated data.
StreamResourceHandler	Handles StreamResource instances registered in VaadinSession.
StreamResourceRegistry	Registry for StreamResource instances.
StreamResourceWriter	Output stream consumer.
StreamVariable	StreamVariable is a special kind of variable whose value is streamed to an OutputStream provided by the StreamVariable.getOutputStream() method.
StreamVariable.StreamingEndEvent	Event passed to StreamVariable.streamingFinished(StreamingEndEvent) method the contents have been streamed to StreamVariable successfully.
StreamVariable.StreamingErrorEvent	Event passed to StreamVariable.streamingFailed(StreamingErrorEvent) method when the streaming ended before the end of the input.
StreamVariable.StreamingEvent	Streaming event interface.
StreamVariable.StreamingProgressEvent	Event passed to StreamVariable.onProgress(StreamingProgressEvent) method during the streaming progresses.
StreamVariable.StreamingStartEvent	Event passed to StreamVariable.streamingStarted(StreamingStartEvent) method before the streaming of the content to StreamVariable starts.
StringToEnumDecoder	Decodes a JsonValue with JsonType.STRING type to Enum subclass type.
StringToNumberDecoder	Decodes a JsonValue with JsonType.STRING type to Number subclass type.
StringUtil	Utility class for special string handling.
Style	Provides inline styles for Elements.
StyleAttributeHandler	Emulates the style attribute by delegating to Element.getStyle().
StyleSheet	Defines style sheet dependencies on a Component class.
StyleSheet.Container	Internal annotation to enable use of multiple StyleSheet annotations.
StyleUtil	Utility methods for Style.
Svg	A component that displays a given SVG image.
Synchronize	Annotates getters for which properties should be synchronized to the server.
SynchronizedRequestHandler	RequestHandler which takes care of locking and unlocking of the VaadinSession automatically.
SystemMessages	Contains the system messages used to notify the user about various critical situations that can occur.
SystemMessagesInfo	Provides information available for SystemMessagesProvider when defining what SystemMessages to use.
SystemMessagesProvider	Gives out system messages based on Locale.
Tag	Defines the tag to use for the root element for a component created using the default Component constructor.
TargetElement	Page target element enum for inlining during bootstrap creation.
TaskCopyFrontendFiles	Copies JavaScript and CSS files from JAR files into a given folder.
TaskCopyLocalFrontendFiles	Copies JavaScript files from the given local frontend folder.
TaskCopyTemplateFiles	Copies template files to the target folder so as to be available for parsing at runtime in production mode.
TaskGenerateBootstrap	A task for generating the bootstrap file FrontendUtils.BOOTSTRAP_FILE_NAME during `package` Maven goal.
TaskGenerateEndpoint	Generate the TS files for endpoints, and the Client API file.
TaskGenerateFeatureFlags	A task for generating the feature flags file FrontendUtils.FEATURE_FLAGS_FILE_NAME during `package` Maven goal.
TaskGenerateIndexHtml	Generate index.html if it is missing in frontend folder.
TaskGenerateIndexTs	Generate index.ts if it is missing in frontend folder.
TaskGenerateOpenAPI	Generate OpenAPI json file for Vaadin Endpoints.
TaskGeneratePackageJson	Creates the package.json if missing.
TaskGenerateServiceWorker	Generate index.html if it is missing in frontend folder.
TaskGenerateTsConfig	Generate tsconfig.json if it is missing in project folder.
TaskGenerateTsDefinitions	Generate types.d.ts if it is missing in project folder and tsconfig.json exists in project folder.
TaskGenerateViteDevMode	Generate vite-devmode.ts if it is missing in frontend/generated folder.
TaskGenerateWebComponentBootstrap	A task for generating the bootstrap file for exported web components FrontendUtils.WEB_COMPONENT_BOOTSTRAP_FILE_NAME during `package` Maven goal.
TaskGenerateWebComponentHtml	Generate web-component.html if it is missing in frontend folder.
TaskInstallFrontendBuildPlugins	Task that installs any Flow webpack plugins into node_modules/@vaadin for use with webpack compilation.
TaskRunDevBundleBuild	Compiles the dev mode bundle if it is out of date.
TaskRunNpmInstall	Run npm install after dependencies have been updated.
TaskRunNpmInstall.Stats	Container for npm installation statistics.
TaskUpdateImports	An updater that it's run when the servlet context is initialised in dev-mode or when flow-maven-plugin goals are run in order to update Flow imports file and "jar-resources" contents by visiting all classes with JsModule and Theme annotations.
TaskUpdatePackages	Updates package.json by visiting NpmPackage annotations found in the classpath.
TaskUpdateSettingsFile	Creates a vaadin-dev-server-settings.json file for use with dev server configuration.
TaskUpdateThemeImport	Task generating the theme definition file 'theme.js' for importing application theme into the generated frontend directory.
TaskUpdateVite	Updates the Vite configuration files according with current project settings.
Template	Marker interface for (Lit and Polymer) templates.
Text	A component which encapsulates the given text in a text node.
TextNodeMap	Map holding the data of a text node.
Theme	Defines the theme to use for the application.
ThemeDefinition	Holds all the settings needed to properly set a Theme in the application.
ThemeList	Representation of the theme names for an Element.
ThemeListImpl	Default implementation for the ThemeList that stores the theme names of the corresponding element.
Transport	Transport modes for Push
UI	The topmost component in any component hierarchy.
UI.ClientViewPlaceholder	Placeholder view when navigating from server-side views to client-side views.
UIDetachedException	Exception thrown if the UI has been detached when it should not be.
UidlRequestHandler	Processes a UIDL request from the client.
UidlWriter	Serializes pending server-side changes to UI state to JSON.
UidlWriter.ResolveContext	Provides context information for the resolve operations.
UIInitEvent	Event fired to UIInitListener when a UI has been initialized.
UIInitListener	Event listener that can be registered for receiving an event when a UI is initialized.
UIInternals	Holds UI-specific methods and data which are intended for internal use by the framework.
UIInternals.JavaScriptInvocation	A Page.executeJs(String, Serializable...) invocation that has not yet been sent to the client.
UIInternalUpdater	The implementation of this interface is responsible for updating the UI with given content.
UniqueSerializable	A base class for generating an unique object that is serializable.
Unit	Enum of supported units in Css sizes.
UnknownFeatureException	Exception thrown for when a FeatureFlag that doesn't exist is checked.
UnknownTaskException	Exception thrown for when a node task that is not in the task list is encountered.
UnsupportedBrowserHandler	A RequestHandler that presents an informative page that the browser in use will not work.
UnsupportedPropertyTypeException	UnsupportedPropertyTypeException is throw when WebComponentExporter tries to register a property encasing an unsupported value type.
UploadException	Upload exception class.
UrlUtil	Internal utility class for URL handling.
UsageStatistics	Collects entries that should be exported for vaadin-usage-statistics when running in development mode.
UsageStatistics.UsageEntry	A usage statistics entry.
UsageStatisticsExporter	A class for exporting UsageStatistics entries.
Uses	Marks that an annotated component implicitly uses another component.
Uses.Container	Internal annotation to enable use of multiple Uses annotations.
VaadinApplicationInitializationBootstrap	Represents Vaadin web application initialization bootstrap.
VaadinAppShellInitializer	Servlet initializer visiting AppShellConfigurator configuration.
VaadinConfig	Configuration in which VaadinService is running.
VaadinContext	Context in which VaadinService is running.
VaadinContextInitializer	Allows to run initialization of VaadinContext which for some reasons may not be done via ServletContextListener.
VaadinContextStartupInitializer	Applies this initializer to the given VaadinContext.
VaadinInitializerException	Indicates an issue during Vaadin initialization.
VaadinRequest	A generic request to the server, wrapping a more specific request type, e.g.
VaadinResponse	A generic response from the server, wrapping a more specific response type, e.g.
VaadinService	An abstraction of the underlying technology, e.g.
VaadinServiceInitListener	Listener for VaadinService initialization events.
VaadinServlet	The main servlet, which handles all incoming requests to the application.
VaadinServletConfig	VaadinConfig implementation for Servlets.
VaadinServletContext	VaadinContext that goes with VaadinServletService.
VaadinServletContextStartupInitializer	Allows a library/runtime to be notified of a web application's startup phase and perform any required programmatic registration of servlets, filters, and listeners in response to it.
VaadinServletRequest	Wrapper for HttpServletRequest.
VaadinServletResponse	Wrapper for HttpServletResponse.
VaadinServletService	A service implementation connected to a VaadinServlet.
VaadinSession	Contains everything that Vaadin needs to store for a specific user.
VaadinSessionState	The lifecycle state of a VaadinSession.
VaadinUriResolver	Utility for translating special Vaadin URIs into URLs usable by the browser.
ValueProvider<SOURCE,TARGET>	A callback interface for providing values from a given source.
Version	Provides information about the current version of Vaadin Flow.
ViewAccessChecker	Checks access to views using an AccessAnnotationChecker.
Viewport	Defines a viewport tag that will be added to the HTML of the host page of a UI class.
VirtualChildrenList	List of nodes describing the virtually connected child elements of an element.
WebBrowser	Provides information about the web browser the user is using that is directly available in the request, for instance browser name and version and IP address.
WebComponent<C extends Component>	Acts as a proxy to the web component root onto which the exporter Component is added.
WebComponentBinding<C extends Component>	Represents a single instance of a exported web component instance embedded onto a host page.
WebComponentBootstrapHandler	Bootstrap handler for WebComponent requests.
WebComponentConfiguration<C extends Component>	Result of defining an embeddable web component using WebComponentExporter.
WebComponentConfigurationRegistry	Registry for storing available web component configuration implementations.
WebComponentConfigurationRegistryInitializer	Servlet initializer for collecting all classes that extend WebComponentExporter/WebComponentExporterFactory on startup, creates unique WebComponentConfiguration instances, and adds them to WebComponentConfigurationRegistry.
WebComponentExporter<C extends Component>	Exports a Component as a web component.
WebComponentExporter.WebComponentConfigurationFactory	Produces WebComponentConfiguration instances from either WebComponentExporter classes or instances.
WebComponentExporterAwareValidator	Checks that specific annotations are not configured wrong.
WebComponentExporterFactory<C extends Component>	Exports a Component as a web component.
WebComponentExporterFactory.DefaultWebComponentExporterFactory<C extends Component>	Default factory implementation which uses an exporter class to instantiate it using its default constructor.
WebComponentExporterTagExtractor	Retrieves web component tag from a WebComponentExporterFactory object.
WebComponentExporterUtils	Internal utility methods for WebComponentExporter and WebComponentExporterFactory classes.
WebComponentGenerator	Generates a client-side web component from a Java class.
WebComponentModulesWriter	Writes web components generated from WebComponentExporter implementation classes to a target directory.
WebComponentModulesWriter.DirectoryWriter	Enables the usage of given WebComponentModulesWriter class via reflection.
WebComponentProvider	Request handler that supplies the script/html of the web component matching the given tag.
WebComponentUI	Custom UI for use with WebComponents served from the server.
WebComponentUI.WebComponentConnectEvent	Event used for sending the activation event for an exported web component from the client to the server.
WebComponentWrapper	Wrapper component for a web component that exposes ClientCallable methods that the client-side components expect to be available.
WildcardParameter	Marks a Navigation url parameter as a wildcard allowing 0-N parameter parts to be bound for this url parameter.
WrappedHttpSession	Wrapper for HttpSession.
WrappedSession	A generic session, wrapping a more specific session implementation, e.g.