All Classes and Interfaces
Class
Description
Validation class that contains common logic to checks that specific
annotations are not configured wrong.
Internal helper for
AttachEvent and DetachEvent.Abstract base class for implementing back end data providers.
Abstract base class for implementing
BackEndHierarchicalDataProviders.Abstract base class for PropertyDefinition implementations for beans.
The common abstract superclass of Collaboration Managers.
The callback executed when the manager is activated, i.e.
Abstract class used as base for DataGenerators that need to manage the
lifecycle of components, according to what items are requested or destroyed.
An abstract field class that is backed by a composite component.
Defines a base contract for configuration (e.g.
A configuration factory base logic which reads the token file.
Abstract base class for model classes to be serialized to JSON.
Base class for all map configuration objects that represent an OL class.
Abstract data provider implementation which takes care of refreshing data
from the underlying data provider.
Abstract data view implementation which handles parts that apply for any type
of data.
An abstract base class for DeploymentConfiguration implementations.
Deals with most details of starting a frontend development server or
connecting to an existing one.
An abstract implementation of a field, or a
Component allowing user
input.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.
Abstract class for common file receiver buffers.
Abstract implementation of a GridMultiSelectionModel.
Abstract implementation of a GridSingleSelectionModel.
Abstract hierarchical data provider implementation which takes care of item
refreshes and associated events.
Abstract base class for icon components
Generic initializer logic.
Abstract lazy data view implementation which handles the interaction with a
data communicator.
Change describing an operation (add/remove) in a
list node
feature.Abstract list data view implementation which provides common methods for
fetching, filtering and sorting in-memory data to all
ListDataView
subclasses.Abstract component for the
<vaadin-login-overlay> and
<vaadin-login-form> components.`forgot-password` is fired when the user clicks Forgot password button
`login` is fired when the user either clicks Submit button or presses an
Enter key.
Class with common functions for Login components LoginForm and LoginOverlay.
SPI for customizing lookup in applications inside Servlet 5.0 containers.
Base class for navigation handlers that target a navigation state.
Abstract implementation of the
ElementStateProvider related to the
composition essence of the provider.Abstract base class for components based on
vaadin-number-field
element and its subclasses.Provides a configuration based on string properties.
Abstract class to be used as a parent for node maps which supports setting
properties in a map.
AbstractRouteRegistry with locking support and configuration.
Configuration interface to use for updating the configuration entity.
Common validation methods for route registry initializer.
Abstract invocation handler implementation with common methods.
Abstract base class for series
Custom bean serializer for
AbstractSeries that adds the type field.Base class for series events.
Abstract superclass for chart series items
Base class for series item events.
Abstract class for collecting Methods which are published as
serverObject.<name> on the client side.Abstract field that is based on a single element property.
Abstract stream resource class.
A converter that converts from the number type T to
String and back.Abstract class for generating client files.
Abstract element state provider for text nodes.
Abstract theme definition class for defining theme variables when in use.
An abstract base class for typed validators.
Checks if a given user has access to a given method.
Options for configuring accessibility for the chart.
Response object when access to Collaboration Engine is requested for a user.
Accordion is a vertically stacked set of expandable panels.
An event fired when an Accordion is opened or closed.
TestBench element for the vaadin-accordion element
An accordion panel which could be opened or closed.
TestBench element for the vaadin-accordion-panel element
Allows dispatching actions to be executed in background.
Defines when to execute the connection callback
Event created after navigation completed.
The base interface for every
AfterNavigationEvent handler.A listener that may be added to the
UI
using
UI.addAfterNavigationListener(AfterNavigationListener).Any attached component implementing this interface will receive an event
after all navigation tasks have resolved.
AllFinishedEvent is sent when the upload has processed all the files in its
upload queue, regardless of whether all the receptions were successful or
not.
Makes a
@ClientCallable method callable even if the UI is inert.Exception indicating that the application's routes already has the navigation
target with the given path.
Component representing an
<a> element.A TestBench element representing an
<a> element.Enum representing
target attribute values for an
<a> element.Represents
target attribute values for an <a>
element.Container for labels on the chart
Label that can be positioned anywhere in the chart area
Contains coordinates for
AnnotationItemLabelHelper class for reading annotation data.
Validation class that is run during servlet container initialization which
checks that specific annotations are not configured wrong.
A security annotation, granting anonymous access to the Vaadin endpoint (or
its method) it is placed onto.
App Layout is a component for building common application layouts.
The internationalization properties for
AppLayoutSections in the component that can be used as primary.
Allows to access the web application classloader.
Configuration on the application level.
A factory for
ApplicationConfiguration.A utility class providing static constants.
Registry for holding navigation target components found on servlet
initialization.
RouteRegistry wrapper class for storing the ApplicationRouteRegistry.
An interface to configure application features and the host page where the
Vaadin application is running.
Checks whether the provided class is an
AppShellConfigurator eligible
for the web application.The registry class for
AppShellConfigurator annotations.A wrapper class for storing the
AppShellRegistry instance in the
servlet context.Initial page settings class for modifying the application shell.
Exception indicating a failure during extraction of an archive file.
Array update strategy aware class.
Array updater strategy.
Component representing a
<article> element.Component representing a
<aside> element.Defines the default assets that the Map component provides
A
PushConnection implementation using the Atmosphere push support
that is by default included in Vaadin.Represents a message that can arrive as multiple fragments.
Event fired after a
Component is attached to the UI.Temporary storage of data required to handle existing element attachment
callback from the client side.
RPC handler for a client-side response on attach existing element request.
Mixin interface for components that support adding attach listeners.
RPC handler for a client-side response on attach existing element by id
request.
Additional qualifier to be used on element classes which do not use an unique
tag name.
Internal annotation to enable use of multiple
Attribute
annotations.A collection of style attributes for the
HaloThe
Attributes class represents a set of attributes.The authentication context of the application.
Helpers for authentication related tasks.
Capitalization options for the
autocapitalize attribute.Values for the
autocomplete attribute.Avatar is a graphical representation of an object or entity, for example a
person or an organisation.
The internationalization properties for
AvatarGroup.A TestBench element representing a
<vaadin-avatar>
element.Avatar Group is used to group multiple Avatars together.
The internationalization properties for
AvatarGroup.Item to be set as an avatar for the avatar group.
A TestBench element representing a
<vaadin-avatar-group>
element.Set of theme variants applicable for
vaadin-avatar-group component.Set of theme variants applicable for
vaadin-avatar component.Possible axis dimensions with their indexes in client-side
Alternative AxisContainer to allow multiple axes
Serializer for
AxisListEvent for information about rescaling the axis.
The AxisStyle class contains options for customizing the style of an axis
The axis title, showing next to the axis line.
Serializer for
AxisTitle.Enum representing different axis types.
Defines the back panel of the frame around 3D charts.
The interface between a cluster backend and Collaboration Engine.
This exception is thrown by the {@link EventLog::subscribe()} method if
the provided
UUID does not exist in the log.A strictly ordered log of submitted events.
The
Snapshot class is used to submit and retrieve a snapshot
payload using the {@link Backend::replaceSnapshot()} and
{@link Backend::loadLatestSnapshot()} methods.A data provider that lazy loads items from a back end.
Exception thrown if the feature-flag for the
Backend API is not
enabled.A data provider that lazy loads items from a back end containing hierarchical
data.
An object, or array of objects, for backgrounds.
The shape of the pane background.
Base class for UI unit tests.
Implementation which stores data for basic elements, i.e.
Implementation of
Style for BasicElementStateProvider.Abstract renderer used as the base implementation for renderers that outputs
a simple value in the UI, such as
NumberRenderer and
LocalDateRenderer.Handles storing and retrieval of the state information for a text node using
a state node.
The feature contains a value of the basic type.
A
DataGenerator that sends all the fields of the objects in the model
to the client, using the field names as property names.A
PropertySet that uses reflection to find bean properties.Contains properties for a bean type which is nested in another
definition.
Abstract class for bean serializers.
Delegates serialization calls to the given instance of
BeanSerializationDelegate.Utility class for Java Beans information access.
Binder that uses reflection based on the provided bean type to resolve bean
properties.
A
Validator using the JSR-303 (jakarta.validation) annotation-based
bean validation mechanism.Event created before navigation happens.
The base interface for every
BeforeEnterEvent handler.A listener that may be added to the
UI
using
UI.addBeforeEnterListener(BeforeEnterListener).Any attached component implementing this interface will receive an event
before a new navigation state is entered.
Abstract before event class that has the common functionalities for
BeforeLeaveEvent and BeforeEnterEvent.Event created before navigation happens.
The base interface for every
BeforeLeaveEvent handler.A listener that may be added to the
UI
using
UI.addBeforeLeaveListener(BeforeLeaveListener).Any attached component implementing this interface will receive an event
before leaving the current navigation state.
BigDecimalField is an input field for handling decimal numbers with high
precision.
A TestBench element representing a
<vaadin-big-decimal-field> element.Validator for validating that an
BigDecimal is inside a given range.Validator for validating that an
BigInteger is inside a given range.Connects one or more
Field components to properties of a backing data
type such as a bean type.Represents the binding between a field and a data property.
Creates a binding between a field and a data property.
An internal implementation of
BindingBuilder.An internal implementation of
Binding.A CRUD editor that binds editor fields to bean properties using a
Binder.Handler for applying effects to
HasValue components in Binder
based on ValidationResult for the user input.Binder validation status change.
Handler for
BinderValidationStatus changes.A subclass of
RuntimeException which may be thrown inside
Binder.Binding logic to wrap an exception caused by HasValue,
validator, converter, etc.Handles an
Exception which may be thrown inside Binder.Binding logic
to be able to identify the originator of the exception (the original
Exception instance usually doesn't contain any information which
HasValue object is the source of the exception).Represents the status of field validation.
Status of the validation.
Handler for
BindingValidationStatus changes.Mixin interface to handle blur events on components.
Represents the DOM event "blur".
Vaadin Board allows creating responsive layouts in an easy way.
This is the base element class for accessing a Vaadin Board component for
TestBench testing.
Defines the body size that will be added to the HTML of the host pages.
A Vaadin internal runtime exception thrown when the writing of the bootstrap
page in
BootstrapHandler fails for some reason.Request handler which handles bootstrapping of the application, i.e.
Provides context information for the bootstrap process.
Builds bootstrap pages.
The URI resolver used in the bootstrap process.
Interface for objects capable of building the bootstrap page.
Helper methods for use in bootstrapping.
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.
The callback used by bootstrap handlers in order to know when a request is a
valid URL to render the page.
The bottom of the frame around a 3D chart.
A DataSeriesItem implementation suitable for
box plot charts.
Enum for the values of the CSS property
box-sizing.An array defining breaks in the axis, the sections defined will be left out
and all the points shifted closer to each other.
Enumerates the most commonly used browsers.
Methods annotated with BrowserConfiguration in test classes will be used to
configure the browsers that are to be used for test cases in that class.
Parses the user agent string from the browser and provides information about
the browser.
Detected operating systems.
BrowserFactory annotation is used to define which
TestBenchBrowserFactory implementation to use in a test.Util for launching a browser instance.
Provides a way to reload browser tabs via web socket connection passed as a
AtmosphereResource.Live reload enabling technology detected.
Deprecated.
Provides API to access to the
BrowserLiveReload instance by a
VaadinService.Default implementation for
BrowserLiveReloadAccessor that stores the
instance in the Vaadin context.Provides helper method for selecting the browser to run on
Event that is fired when a browser window containing a uI is resized.
Listener that gets notified when the size of the browser window containing
the uI has changed.
Parse statistics data provided by webpack.
Bundle handling methods.
The Button component allows users to perform actions.
A TestBench element representing a
<vaadin-button>
element.
A collection of options for buttons appearing in the exporting module.
Positioning options for
DrillUpButtonOptions for the export related buttons, print and export.
Tester for Button components.
Set of theme variants applicable for
vaadin-button component.Validator for validating that an
Byte is inside a given range.Data provider that uses one callback for fetching items from a back end and
another callback for counting the number of available items.
Callback interface for counting the number of items in a backend based on
a query.
Callback interface for fetching a stream of items from a backend based on
a query.
Utilities related to various case operations.
Event fired when a cell in the Grid is focused.
An enum representing the different sections of a grid.
Vaadin Charts is a feature-rich interactive charting library for Vaadin.
The ChartAddSeriesEvent class stores data about new series added to an
existing chart.
Fired after a chart is printed using the print menu
Fired before a chart is printed using the print menu
The ChartClickEvent class stores information on click events anywhere on the
area of the chart.
ChartDrillupEvent triggered after all the series has been drilled up if chart
has multiple drilldown series
ChartDrillupEvent triggered when the 'Back to previous series' button is
clicked
Interface shared by all enum classes of the vaadin charts.
Serializer for all classes implementing
ChartEnumFired after a chart is loaded
Options regarding the chart area and plot area as well as general chart
options.
The ChartOptions configures a page local global options like localized texts
for charts.
Fired after a chart is redrawn
The ChartSelectionEvent class stores information on selection events on the
chart's area.
Util class that handles the configuration needed for the model classes to be
serialized to JSON.
Styles of chart
Tester for Chart components.
The default series type for the chart.
Set of theme variants applicable for
vaadin-chart component.Checkbox is an input field representing a binary choice.
A TestBench element representing a
<vaadin-checkbox>
element.CheckBoxGroup is a multi-selection component where items are displayed as
check boxes.
Implementation of generic data view for checkbox group.
Data view implementation for Checkbox Group with in-memory list data.
Tester for CheckboxGroup components.
Set of theme variants applicable for
vaadin-checkbox-group component.Tester for Checkbox components.
Callback which allows to handle request to map a client side DOM element to
the server
Element instance.Identifier for a chunk or part of the JS bundle.
Emulates the
class attribute by delegating to
Element.getClassList().Interface for annotated and subclass class searches.
Implementation that proxy and cache a real
ClassFinder.Implementation that searches for annotated classes or subclasses in a
list of classes.
Representation of the class names for an
Element.Allows to load the implementation class by one classloader but accepts
classes in
ClassLoaderAwareServletContainerInitializer.onStartup(Set, ServletContext) method loaded by another
classloader.Represents a clickable renderer.
Listener that receives the clicked item (or tapped item, in touch
devices).
Event fired when a component is clicked.
Mixin interface for components that support adding click listeners to the
their root elements.
Publishes the annotated method so it can be invoked from the client side
using the notation
this.$server.method().Methods which are published as
element.$server.<name> on
the client side.A utility class that allows preventing the web component from setting itself
to valid as a result of client-side validation.
Extension of the
AvatarGroup component which integrates with the
CollaborationEngine.Callback for creating a stream resource with the image for a specific
user.
Extension of
Binder for creating collaborative forms with
CollaborationEngine.Utility methods for
CollaborationBinder.CollaborationEngine is an API for creating collaborative experiences in
Vaadin applications.
Configuration object for
CollaborationEngine.A
VaadinServiceInitListener which uses the Instantiator to
find whether an instance of CollaborationEngineConfiguration is
provided as a bean in the current environment, using that instance if found.A list that is shared between multiple users.
A map that is shared between multiple users.
Message of a
CollaborationMessageList.Extension of the
MessageInput component which integrates with the
CollaborationMessageList.Extension of the
MessageList component which integrates with the
CollaborationEngine.Configurator callback for messages in a
CollaborationMessageList.Persister of
CollaborationMessage items, which enables to read and
write messages from/to a backend, for example a database.A query to fetch messages from a backend.
A request to persist messages to a backend.
Submitter of messages.
The activation context of a
CollaborationMessageSubmitter.Interface used for different type of colors used in model and theme
Renderer for columns that doesn't use a renderer function for rendering its
contents (only the value from the object model).
Constants for the rendering mode of columns.
Event fired when the columns in the Grid are reordered.
Event fired when a Grid column is resized by the user.
Constants for the text alignment of columns.
Combo Box allows the user to choose a value from a filterable list of options
presented in an overlay.
A callback method for fetching items.
Predicate to check
ComboBox items against user typed strings.Provides base functionality for combo box related components, such as
ComboBoxEvent that is dispatched from a combo box component, if the component
allows setting custom values, and the user has entered a non-empty value
that does not match any of the existing items
Customized data communicator that uses a custom key mapper for preserving
keys of selected items when using lazy-loading.
Customized key mapper that does not remove key for an item as long as it
is selected.
Implementation of generic data view for ComboBox.
A TestBench element representing a
<vaadin-combo-box>
element.Data view implementation for ComboBox with lazy data fetching.
Data view implementation for ComboBox with in-memory list data.
Set of theme variants applicable for
vaadin-combo-box component.A generic command interface meant to be used for passing lambdas around.
The
YAxis will show percentage or absolute change depending on
whether compare is set to Compare.PERCENT or Compare.VALUEA connection context based on the attach state of a set of component
instances.
A
DataGenerator that
manages the creation and passivation of components generated by
ComponentRenderers.An event whose source is a
Component.An event bus for
Components.Static helpers and caching functionality for
ComponentEventBus.Generic listener for component events.
A server side only node feature for mapping a node to a component.
Immutable meta data related to a component class.
Dependencies defined for a
Component class.Synchronized properties defined for a
Component class.Query class used for finding a component inside a given search context.
Base class for all renderers that support arbitrary
Components.Test wrapper for components with helpful methods for testing a component.
Annotation to use to scan given packages for component wrappers outside the
default
com.vaadin.flow.component.Tracks the location in source code where components were instantiated.
Represents a location in the source code.
Utility methods for
Component.A composite encapsulates a
Component tree to allow creation of new
components by composing existing components.A
DataGenerator that aggregates multiple DataGenerators and delegates
the data generation to them.The event when a composition is ended.
Abstract class for composition events.
Mixin interface for components that support adding composition listeners to
the their root elements.
The event when a composition is started.
The event when a composition is updated.
Under which conditions the rule applies.
A data provider that supports programmatically setting a filter that will be
applied to all queries.
A configurable data provider that wraps another data provider by combining
any filter from the component with the configured filter and passing that to
the wrapped provider through the query.
Chart's configuration root object containing all the child objects that are
used to configure chart, axes, legend, titles etc.
Contains the configuration for the map, such as layers, sources, features.
Listener interface for events triggered in Configuration.
Route configuration class that is used as a value object.
Configuration class for editing routes.
Confirm Dialog is a modal Dialog used to confirm user actions.
`cancel` is sent when the user clicks Cancel button or presses Escape
key.
`confirm` is sent when the user clicks Confirm button
`reject` is sent when the user clicks Reject button
Tester for ConfirmDialog.
The context in which a topic connection is active.
Keeps track of
ConstantPoolKey values that have already been sent to
the client.Wraps a JSON value that should be stored in the
ConstantPool shared
between the client and the server.Defines constants for OpenLayers types, which are uses by the client-side
synchronization mechanism to identify which OL class to construct and
synchronize into.
Constants used by the server side framework.
Content type resolver.
Options for the export button.
Context Menu is a component that you can attach to any component to display a
context menu.
ContextMenuBase<C extends ContextMenuBase<C,I,S>,I extends MenuItemBase<C,I,S>,S extends SubMenuBase<C,I,S>>
Base functionality for server-side components based on
<vaadin-context-menu>.opened-changed event is sent when the overlay opened state
changes.A TestBench element representing a
<vaadin-context-menu>
element.Tester for ContextMenu components.
Defines conversion between a model and a presentation type.
Creates
Converter instances capable to handle conversion between a
model and a presentation type.Cookie Consent is a component for showing a cookie consent banner the first
time a user visits the application, until the banner is dismissed.
Position of the banner.
Default values for the element properties.
Represents map coordinates in a specific projection.
Highchart by default puts a credits label in the lower right corner of the
chart.
Configure a crosshair that follows either the mouse pointer or the hovered
point.
A label on the axis next to the crosshair.
A component for performing CRUD
operations on a data backend (e.g entities from a database).
Event fired when the user cancels the creation of a new item or
modifications to an existing item.
Event fired when the user tries to delete an existing item.
Event fired when the user starts to edit an existing item.
Determines whether an item presented for editing is to be treated as a
new item or an existing item.
Event fired when the user starts to create a new item.
Event fired when the user tries to save a new item or modifications to an
existing item.
Interface representing a crud editor.
Enum with the possible values for the crud's editor position.
TestBench element for the vaadin-crud element
The filter type for use with
CrudGrid.A simple grid implementation for Crud that allows searching and sorting
backed by a data provider.
Internationalization object for customizing the component UI texts.
The confirmation dialogs used in the component
Represents texts in the confirmation dialogs
The confirmation options on a dialog
Event fired to a crud grid when the internationalization object is changed.
The set of theme variants applicable to the
vaadin-crud component.A container for CssImport information when scanning the class path.
Imports a CSS file into the application bundle.
Internal annotation to enable use of multiple
CssImport
annotations.Keeps track of various current instances for the current thread.
You can set the cursor to POINTER("pointer") if you have click events
attached to the series, to signal to the user that the points and lines can
be clicked.
Callback for handling attributes with special semantics.
Validates custom-element name according to definition in Custom
element name
A
HasValue whose UI content can be constructed by the user, enabling
the creation of e.g.The set of theme variants applicable to the
vaadin-custom-field
component.Contains the system messages used to notify the user about various critical
situations that can occur.
Utilities for commercial product handling.
Dash styles used to render lines.
Event triggered when data was added to the series.
An event fired when the data of a
DataProvider changes.An event fired when a single item of a
DataProvider has been
updated.DataProvider base class.
In-memory data provider with no items.
Wraps the component's filter object with the meta information whether
this filter changing should trigger the item count change event.
A data generator for
DataCommunicator.
Data grouping is the concept of sampling the data values into larger blocks
in order to ease readability and increase performance of the JavaScript
charts.
DataKeyMapper to map data objects to key strings.
Options for the series data labels, appearing next to each data point.
Extended data labels for range series types.
A common interface for fetching data from a backend.
Data change events listener.
A series which is based on data from a DataProvider.
Custom bean serializer for
DataProviderSeriesWrapper class for modifying, chaining and replacing filters and sorting in a
query.
Event when the data was removed.
An array of data points to be displayed in a chart.
The DataSeriesItem class represents a single entry in a
DataSeries.DataSeriesItem that can hold also Z value.
Custom bean serializer for
DataSeriesItemDataSeriesItem that can hold also target and targetOptions.
DataSeriesItem that can hold also Label and Description values.
DataSeriesItem that can hold also x2 and partialFill amount and color.
Event for updating existing data series.
Base view interface for getting information on current data set of a
Component.
Internal utility class used by data view implementations and components to
simplify the filtering and sorting handling, but not limited to it.
Date Picker is an input field that allows the user to enter a date by typing
or by selecting from a calendar overlay.
The internationalization properties for
DatePicker.invalid-changed event is sent when the invalid state changes.opened-changed event is sent when the overlay opened state
changes.A TestBench element representing a
<vaadin-date-picker>
element.Tester for the DatePicker components.
Set of theme variants applicable for
vaadin-date-picker component.Validator for validating that a
LocalDate is inside a given range.Serializes all
Date objects as UTC long.For a DATETIME axis, the scale will automatically adjust to the appropriate
unit.
Date Time Picker is an input field for selecting both a date and a time.
Contains DateTimePicker internalization properties
A TestBench element representing a
<vaadin-date-time-picker> element.Tester for DateTimePicker components.
Set of theme variants applicable for
vaadin-date-time-picker
component.Validator for validating that a
LocalDateTime is inside a given
range.A completable future that will throw from blocking operations if the current
thread holds the session lock.
Defines phases for an event that is debounced.
Debounce settings for declaratively defined client-side event handlers.
BrowserLiveReload implementation class.Implementation of the development tools interface.
A message sent to the debug window.
Default implementation of
ApplicationConfigurationFactory.Default implementation for file archive extraction.
Logic for altering the bean serialization process.
Default implementation of
BinderValidationErrorHandler.Default implementation of
BindingExceptionHandler.Default implementation of
ConverterFactory, handling all standard
converters defined in com.vaadin.flow.data.converters package.The default implementation of
DeploymentConfiguration based on a base
class for resolving system properties and a set of init parameters.Marks an HasErrorParameter view as Framework default handler so it can be
disregarded if there is a custom view for the same Exception.
The default implementation of
ErrorHandler.Default file downloader implementation.
Default instantiator that is used if no other instantiator has been
registered.
Default implementation for
RoutePathProvider.Default implementation of the
RouteResolver interface.Decodes the standard basic types from their JSON representation.
System messages provider using the built-in default system messages.
Represents an html import, stylesheet or JavaScript to include on the page.
The type of a dependency.
Filter for dependencies loaded using
@StyleSheet, and *
@JavaScript.List for storing dependencies/files (JavaScript, Stylesheets) to be loaded
and included on the client side.
A caching tree traverser for collecting and parsing dependencies.
Marks which classes should trigger loading of a chunk defined by a route.
A collection of properties configured at deploy time as well as a way of
accessing third party properties not explicitly supported by this class.
Creates
DeploymentConfiguration filled with all parameters specified
by the framework users.Deprecated.
Polymer template support is deprecated - we recommend you to use
LitTemplate instead.Deprecated.
Polymer template support is deprecated - we recommend you to use
LitTemplate instead.Component representing a
<dl> element.Component representing a
<dd> element.Component representing a
<dt> element.A TestBench element representing a
<dl> element.Event fired before a
Component is detached from the UI.Mixin interface for components that support adding detach listeners.
Details is an expandable panel for showing and hiding content from the user
to make the UI less crowded.
Tester for Details components.
The set of theme variants applicable to the
vaadin-details component.Helpers related to the development bundle.
Utilities for launching a browser when running in development mode.
Provides API to access to the
DevModeHandler instance by a
VaadinService.Provides API to access to the
DevModeHandler instance.Initializer for starting node updaters as well as the dev mode server.
Trigger for running dev mode initialization when running in a compatible
servlet environment.
Singleton for collecting development time usage metrics
Tracks the output of a dev server and scans for given success and/or failure
patterns while copying the dev server output to standard output.
Encapsulates the result of a find operation.
For interfacing with the development tools by plugins.
Handles dev tools messages from the client.
Options for the dial or arrow pointer of the gauge.
A Dialog is a small window that can be used to present information and user
interface elements in an overlay.
`vaadin-dialog-close-action` is sent when the user clicks outside the
overlay or presses the escape key.
Class for adding and removing components to the footer part of a dialog.
Class for adding and removing components to the header part of a dialog.
`resize` event is sent when the user finishes resizing the overlay.
opened-changed event is sent when the overlay opened state
changes.A TestBench element representing a
<vaadin-dialog>
element.Set of theme variants applicable for
vaadin-dialog component.Axial dimension.
Specifies the direction of the text and other content inside of an element.
Controls RPC communication from the client side to the server side respecting
enabled state.
Component representing a
<div> element.A TestBench element representing a
<div> element.Internal class for drag and drop related utility methods.
Maps a DOM event to a
ComponentEvent.Server-side representation of a DOM event fired in the browser.
Server-side listener for client-side DOM events.
A registration for configuring or removing a DOM event listener added to an
element.
Validator for validating that a
Double is inside a given range.HTML5 drag end event, fired when the user stops dragging a drag source either
by dropping on top of a valid drop target or by canceling to drop.
Mixin interface that provides basic drag source API for any component.
HTML5 drag start event, fired when the user starts dragging a drag source.
Server-side component for the
<vaadin-drawer-toggle> element.Options for drill down, the concept of inspecting increasingly high
resolution data through clicking on chart items like columns or pie slices.
Handler interface for chart's drilldown callbacks.
The DrilldownEvent class stores information on click events in drilldown
points
Options for the drill up button that appears when drilling down on a series.
What box to align the button to.
A collection of style attributes for the
DrillUpButtonUsed to specify the drop effect to use on dragenter or dragover events.
Server side drop event.
Mixin interface that provides basic drop target API for any component.
Exception indicating a conflict between a route target implementing
HasDynamicTitle while also having a PageTitle annotation.Configuration for the editor of an edit column.
An editor in a Grid.
Holds the data for cancel events fired in
Editor.An event listener for a
Grid editor cancel events.Holds the data for close events fired in
Editor.An event listener for a
Grid editor close events.Base class for events fired in
Editor.Implementation of
Editor interface.Holds the data for open events fired in
Editor.An event listener for a
Grid editor open events.Renderer and DataGenerator used by
Grid.Column to control the state of the
editor components.Holds the data for save events fired in
Editor.An event listener for a
Grid editor save events.Set of editor types applicable for editor of the
vaadin-grid-edit-column component.Used to specify the effect that is allowed for a drag operation.
Represents an element in the DOM.
Defines the tag name of the element class.
Event fired after an Element has been attached to the UI.
Listener for element attach events.
Map for element attribute values.
List of nodes describing the child elements of an element.
Handles CSS class names for an element.
A collection of commons predicates to be used as
ComponentQuery
conditions.Constants for common element attribute, property, style names.
Map of basic element information.
Event fired after an element has been detached from the UI.
Listener for element detach events.
Helpers to create
Element instances.Map of DOM events with server-side listeners.
Map for element property values.
Query class used for finding a given element inside a given search context.
Handles storing and retrieval of the state information for an element using a
state node.
Map for element style values.
Provides utility methods for
Element.Email Field is an extension of Text Field that only accepts email addresses
as input.
A TestBench element representing a
<vaadin-email-field>
element.A string validator for e-mail addresses.
Component representing a
<em> element.A TestBench element representing an
<em> element.Empty change for the feature to report its presence for the client (send the
feature information even though its data is empty).
Brings in the machinery to setup Spring + Vaadin applications.
Utilities related to various encoding schemes.
A factory for creating Vaadin Endpoint generator tasks.
A container for utility methods related with Hilla endpoints.
A simple container with the information related to an application entry
point, i.e.
The type of an entry point (scanned for frontend dependencies).
The scope of data in a topic.
Class for holding position and size of a error found during image comparison
An error thrown by the framework and handled by an
ErrorHandler.Application errors handler.
Defines the interface to handle exceptions thrown during the execution of a
FutureAccess.
Represents the error levels displayed on components.
Provider interface for generating localizable error messages using
ValueContext.Event object with data related to error navigation.
Servlet initializer for collecting all available error handler navigation
targets implementing
HasErrorParameter on startup.Navigation error parameter class containing thrown exception and possibly a
custom message.
Interface class for RouteRegistries that can be used to request for error
navigation views for Exceptions.
Handles error navigation rendering in the target UI.
A pair of a navigation target for handling exceptions and the exception type
handled by the navigation target.
Maps data from a DOM event to a
ComponentEvent.Cache for tracking global information related to
ComponentEvent
types.EventOptions is used to configure the custom event published by an
exported web component.RPC handler for events.
Event handling utilities.
Marker interface for a TestBench test class which will exclude the test from
any test suite which automatically scans for test classes.
Context of a callback execution when
UI.beforeClientResponse(com.vaadin.flow.component.Component, com.vaadin.flow.function.SerializableConsumer)
is invoked.Thrown by
FallibleCommand if it's unable to complete its execution.Default MIME type for exporting if chart.exportChart() is called without
specifying a type option.
Options for the exporting module.
Provides extended information about the web browser, such as screen
resolution and time zone.
Defines an area within a map using min/max coordinates.
FailedEvent event is sent when the upload is received, but the reception is
interrupted for some reason.
A generic command which may fail.
Handles the favicon request explicitly and return 404 for it.
Information about a feature available behind a flag.
A geographic feature to be displayed on a map.
Stores information about a
Feature that is part of an eventMessage with feature flags sent to the debug window.
Tracks available feature flags and their status.
FeatureFlags wrapper class for storing the FeatureFlags object.
Layer that allows to conveniently display a number of geographic features.
Basic in file receiver implementation.
Class containing file information for upload.
File factory interface for generating file to store the uploaded data into.
Sent when the file selected for upload doesn't meet the constraints specified
on
UploadWatches for the file or sub-directory changes in the given directory.
Internal filter related utilities for data provider.
FinishedEvent is sent when the upload receives a file, regardless of whether
the reception was successful or failed.
DataSeriesItem that can hold also title and text values.
The name of a symbol to use for the border in
ChartType.FLAGS series.A component which implements Flexbox.
Enum with the possible values for the component alignment inside the
layout.
Enum with the possible values for the way the extra space inside the
layout is distributed among the components.
A layout component that implements Flexbox.
Enum with the possible values for the component alignment inside the
layout.
Possible values for the
flex-direction CSS property, which
determines how the elements are placed inside the layout.Possible values for the
flex-wrap CSS property, which determines
how the elements inside the layout should behave when they don't fit
inside the layout.Validator for validating that a
Float is inside a given range.Represents a component that can gain and lose focus.
Mixin interface to handle focus events on components.
Represents the DOM event "focus".
Component for displaying an icon from a font icon collection.
Font weight used by Style class
Component representing a
<footer> element.One row of
FooterRow.FooterCells in a Grid.A footer cell in a Grid.
Form Layout allows you to build responsive forms with multiple columns and to
position input labels on top or to the side of the input.
Server-side component for the
<vaadin-form-item> element.A class used in describing the responsive layouting behavior of a
FormLayout.Enum for describing the position of label components in a
FormLayout.FormItem.A TestBench element representing a
<vaadin-form-layout>
element.Manager to handle form values and field highlight state.
Creates an
HttpServletRequestWrapper instance which returns
appropriate servletPath and pathInfo (which are expected by
VaadinServlet) in case forwarding is enforced.Provides the option to draw a frame around the charts by defining a bottom,
front and back panel.
Represents the class dependency tree of the application.
Frontend dependencies scanner.
Frontend dependencies scanner factory.
Provides access to frontend tools (Node.js and npm, pnpm) and optionally
installs the tools if needed.
Helps to locate the tools in the system by their names.
Configuration object for controlling the
FrontendTools features.A class for static methods and definitions that might be used in different
locations.
Thrown when the command execution fails.
Thrown when detecting the version of a tool fails.
Version object for frontend versions comparison and handling.
Generates embeddable web component files in npm mode, hiding the complexity
caused by using a different class loader.
Encapsulates a
Command submitted using
VaadinSession.access(Command).Collect generated-flow-imports content for project to use to determine if
dev-bundle contains all required imports.
Global options that don't apply to each chart.
Class providing gradient colors
Grid is a component for showing tabular data.
A helper base class for creating extensions for the Grid component.
Server-side component for the
<vaadin-grid-column> element.Builder for
DataCommunicator object.Multi-sort priority (visually indicated by numbers in column headers)
controls how columns are added to the sort order, when a column becomes
sorted, or the sort direction of a column is changed.
behavior when parsing nested properties which may contain
null values in the property chainSelection mode representing the built-in selection models in grid.
Array update strategy aware class for Grid.
Data object for
TreeGridArrayUpdater.A TestBench element representing a
<vaadin-grid-column>
element.Server-side component for
<vaadin-context-menu> to be used with
Grid.Event that is fired when a
GridMenuItem is clicked inside a
GridContextMenu.Implementation of generic data view for grid.
Drag end event of
Grid rows.Drag start event of
Grid rows.Drop event that occurs on the
Grid or its rows.Defines drop locations within a Grid row.
Defines the locations within the Grid row where an element can be dropped.
A TestBench element representing a
<vaadin-grid> element.Data view implementation for Grid with lazy data fetching.
Data view implementation for Grid with in-memory list data.
Item component used inside
GridContextMenu and GridSubMenu.Multiselection model interface for Grid.
State for showing the select all checkbox in the grid's default header
row for the selection column.
Selection model implementation for disabling selection in Grid.
Event fired when the user starts to edit an existing item.
Server-side component for the
<vaadin-grid-edit-column> element.Event fired when the user has edited an existing item.
A TestBench element representing a
<vaadin-pro-grid-edit-column> element.A TestBench element representing a
<vaadin-grid-pro>
element.Set of theme variants applicable for
vaadin-grid-pro component.Server side implementation for the flow specific grid selection column.
The server-side interface that controls Grid's selection state.
Single selection model interface for Grid.
Sorting information for
Grid.Helper classes with fluent API for constructing
GridSortOrder lists.API that allows adding content into the sub menus of a
GridContextMenu to create hierarchical menus.Tester for Grid components.
A TestBench element representing a
<td> or
<th> element in a grid.A TestBench element representing a
<td> or
<th> element in a grid.A TestBench element representing a
<tr> element in a grid.A TestBench element representing a
<tr> element in a grid.Set of theme variants applicable for
vaadin-grid component.Marks a type, method, constructor of field to be ignored by the GWT compiler.
Component representing a
<h1> element.A TestBench element representing an
<h1> element.Component representing a
<h2> element.A TestBench element representing an
<h2> element.Component representing a
<h3> element.A TestBench element representing an
<h3> element.Component representing a
<h4> element.A TestBench element representing an
<h4> element.Component representing a
<h5> element.A TestBench element representing an
<h5> element.Component representing a
<h6> element.A TestBench element representing an
<h6> element.
Options for the halo appearing around the hovered point in line-type series
as well as outside the hovered slice in pie charts.
Contains helper methods for
VaadinServlet and generally for handling
VaadinRequests.Framework internal enum for tracking the type of a request.
Options for the handles for dragging the zoomed area.
Mixin interface for field components that support setting allowed char
pattern to prevent user from entering invalid characters when typing or
pasting text.
A generic interface for components and other user interface objects that may
have an aria-label and an aria-labelledby DOM attributes to set the
accessible name of the component.
Mixin interface for fields with
autocapitalize attribute.Mixin interface for fields with
autocomplete attribute.Mixin interface for fields with
autocorrect attribute.Mixin interface for field components that support setting auto open to
control whether the overlay should open on input click or not.
Mixin interface for components that support a clear button.
Mixin interface for subscribing to the client-side `validated` event from a
component.
An event fired by the web component whenever it is validated on the
client-side.
A component to which the user can add and remove child components.
Defines the contract of adding and removing multiple
DataGenerators
to a given object.A generic interface for listing components that use a data provider for
showing data.
An interface for components that get items from the generic data provider
types
DataProvider and InMemoryDataProvider.An interface for classes that can provide an instance of a
WebDriverAllows to resolve navigation target title dynamically at runtime.
Marker interface for any class which is based on an
Element.A generic interface for components and other user interface objects that may
be enabled or disabled.
Defines a view that handles the exceptions for the set Exception type T.
Common interface to be implemented by types holding data associated to a
topic, which provides methods to set an expiration timeout on the data which
will be cleared after the timeout has passed since the last connection to the
topic has been closed.
A generic interface for listing components that use a filterable data
provider for showing data.
Mixin interface for field components that have helper text as property and
slots for inserting components.
Implement by elements which support a label, i.e.
A generic interface for hierarchical listing components that use a data
provider for showing hierarchical data.
Indicates that an event has an associated item
Represents a component that can have additional components between the items.
Represents a single item component that is used inside a
HasItemComponents.Mixin interface for components that displays a collection of items.
Represents a component that display a collection of items and can have
additional components between the items.
A component that supports label definition.
Implement by elements which support a label, i.e.
Interface that defines methods for fetching items lazily from a backend.
An interface for components that accept setting items in-memory and returns a
ListDataView that provides information and allows operations on the
items.A common interface for components that can have
MenuItems with click
listeners inside them.A component which the children components are ordered, so the index of each
child matters for the layout.
Mixin interface for components that have an internal overlay and support
setting CSS class names on it for styling.
Implement by elements which support a placeholder, i.e.
Mixin interface for components that have a prefix slot.
Interface for classes providing a
SearchContext, i.e.Implemented by elements which support selecting an option by matching the
text shown to the user.
Indicates that an event has an associated series
Any component implementing this interface supports setting the size of the
component using
HasSize.setWidth(String), HasSize.setHeight(String),
HasSize.setMaxWidth(String), HasSize.setMaxHeight(String),
HasSize.setMinWidth(String), and HasSize.setMinHeight(String).Represents
Component which has class attribute and inline styles.Mixin interface for components that have a suffix slot.
Interface for classes that have access to a
TestBenchCommandExecutor
instance.A component that supports text content.
Represents
"white-space" style values.Represents
Component which has theme attribute.Mixin interface that allows adding and removing typed theme variants to /
from a component
Mixin interface for components that have special handling for tooltips on the
Web Component level.
Defines route parameters for navigation targets for use in routing.
Utility methods to transform urls and parameters from/into the
HasUrlParameter format into/from the template format.A component that supports input validation.
Mixin interface for components that provide properties for setting invalid
state and error message string to show when invalid.
A generic interface for field components and other user interface objects
that have a user-editable value that should be validated.
A generic interface for field components and other user interface objects
that have a user-editable value.
An event fired when the value of a
HasValue changes.A listener for value change events.
A component that has a value.
Denotes that the component is able to change the way its value on the client
side is synchronized with the server side.
Component representing a
<header> element.One row of
HeaderRow.HeaderCells in a Grid.A header cell in a Grid.
Event created for an application heartbeat from the client.
Handles heartbeat requests.
Listener for listening to the heartbeat of the application.
A specialized series for use with HeatMaps
Hierarchical array update strategy aware class.
Array updater strategy that is aware of hierarchical changes.
HierarchicalCommunicationController controls all the communication to client.
A hierarchical data provider that supports programmatically setting a filter
that will be applied to all queries.
Data communicator that handles requesting hierarchical data from
HierarchicalDataProvider and sending it to client side.A common interface for fetching hierarchical data from a data source, such as
an in-memory collection or a backend database.
Immutable hierarchical query object used to request data from a backend.
Renders components as hierarchy column for tree grid.
Mapper for hierarchical data.
An action to be performed to set the highlight state of the target.
A set of predefined
HighlightActions.A condition to meet to determine the highlight state of the target.
A set of predefined
HighlightConditions.Functional interface that defines how to handle highlight changes for
properties in a topic.
The context of the highlight.
Represents
window.history in the browser.Event fired when the history state has changed.
Handles location change events.
Alignment of the title relative to the axis values and more generically
horizontal alignment.
Horizontal Layout places components side-by-side in a row.
A TestBench element representing a
<vaadin-horizontal-layout> element.Options for the hovered series
Component representing a
<hr> element.A TestBench element representing an
<hr> element.A component which encapsulates a given HTML fragment with a single root
element.
Base class for a
Component that represents a single built-in HTML
element.Base class for a
Component that represents a single built-in HTML
element that can contain child components or text.Component representing a
<object> element.Helpers for HTML related aspects.
HTTP status codes as defined in RFC 2068.
I18N provider interface for internationalization usage.
Component for displaying an icon from the
Vaadin Icons collection.
An icon or image that can be used to visually represent a
Feature, by
using it as the feature's Style.setImage(ImageStyle)A TestBench element representing a
<vaadin-icon> element.Factory for icons.
A renderer that renders each item as a text following by an icon using
provided icon generator and label generator.
Defines the id of a component or an element to map to inside a lit template.
Collects information of
@Id mapped fields in a template class.Integration with IDEs for development mode.
A callback interface that is used to provide the identifier of an item.
Event notifying the component that its identifier provider has been changed
through a data view.
Creates or maps Element instances to fields mapped using
@Id.Component representing a
<iframe> element.Importance types.
Sandbox types.
Thrown to indicate that an element had an illegal or inappropriate attribute.
Component representing a
<img> element.Class with features for comparing 2 images.
A TestBench element representing an
<img> element.Layer for server-rendered images that are available in arbitrary extents and
resolutions.
Abstract base class for all sources providing a single image
Abstract base class for drawing image-based features
These image utility functions are for internal use only.
Contains ImageUtil-internal information about an image.
Source for WMS servers providing single, untiled images
Immutable class list implementation.
A style implementation which is empty and immutable.
This class is responsible for serving the
index.html according
to the template provided in the frontend folder.This event listener is notified when the Single Page Application's HTML page
is about to be generated and sent to the client.
This represents the state of a Index HTML response being generated.
Server-side feature defining whether a node is inert, and if it should ignore
inheriting inert state from parent.
Constants for all servlet init parameters.
Three argument consumer.
Initialize a lit template element with data.
Defines files to inline into the initial page.
Internal annotation to enable use of multiple
Inline annotations.Inline position enum.
File content wrapping enum.
Data holder class for collected
Inline annotations to be added to the
initial page.A mixin interface for in-memory data providers.
Helper methods for implementing
InMemoryDataProviders.Component representing an
<input> element.Event fired when the component has received any type of input (e.g.
A common interface for input fields that can be used to iterate over a
collection of fields and set common properties.
Mixin interface for components that support adding input listeners to the
their root elements.
Creates input stream instances that provides the actual data of a
StreamResource.A TestBench element representing an
<input type='text'>
element.Exception indicating a failure during installation of node and npm.
Delegate for discovering, creating and managing instances of various types
used by Flow.
A factory for an
Instantiator.Serializes all
Instant objects as UTC long.IntegerField is an extension of Text Field that only accepts integer numbers.
A TestBench element representing a
<vaadin-integer-field>
element.Validator for validating that an
Integer is inside a given range.Handles navigation by redirecting the user to some location in the
application.
This is a basic default error view shown on exceptions during navigation.
Irregular time unit used to define point interval unit.
Exception indicating that the application's routes have been configured
incorrectly.
Exception indicating that the custom-element name is invalid.
Exception indicating that the application's I18N localization has been
configured incorrectly.
Thrown to indicate that a
Location instance is invalid.Exception indicating that the application's routes have been configured
incorrectly.
Exception indicating that Route layouts configuration has problems.
Event fired when a Grid item is clicked.
Event describing the item count change for a component.
Listener interface for getting updates on data item count changes.
Event fired when a Grid item is double clicked.
ItemLabelGenerator can be used to customize the string shown to the
user for an item.PartialFill configuration object to be used in
DataSeriesItemXrange.A HTML label that can be positioned anywhere in the chart area.
Event for information about slicing a pie point
Callback that is called when a new value has been entered to an editor.
Shared code for managing contents of jar files.
Defines JavaScript dependencies on a
Component class.Internal annotation to enable use of multiple
JavaScript
annotations.Processes a 'start' request type from the client to initialize server session
and UI.
Custom BootstrapContext for
JavaScriptBootstrapHandler.Handle navigation events in relation to the client side bootstrap UI.
Helpers for replicating JavaScript semantics in Java.
Annotation for defining JavaScript Module dependencies on a
Component
class.Internal annotation to enable use of multiple
JsModule
annotations.Utility for encoding objects to and from JSON.
A utility class providing constants for JSON related features.
Thrown when unable to convert back and forth between a Java object instance
and a Jackson
JsonNode instance.Base interface for classes that are serializable to and from
JsonObject.General-purpose serializer of Java objects to
JsonValue and
deserializer of JsonValue to Java objects.Helpers for using
elemental.json.Initializer class for JSR 356 websockets.
"ServletConfig" which only provides information from a
ServletRegistration and its ServletContext.An interface to represent keyboard keys.
Abstract class for keyboard events.
Options for keyboard navigation.
The event when a key is pressed.
A conditional event listener for
KeyboardEvents.Possible keyboard key locations.
KeyMapper is the simple two-way map for generating textual keys
for objects and retrieving the objects later with the key.Modifier keys.
Mixin interface for components that support adding key event listeners to the
their root elements.
The event when a key is pressed.
The event when a key is released.
Text labels for the plot bands
Deprecated, for removal: This API element is subject to removal in a future version.
Use
NativeLabel instead, if you need the HTML
<label> element, which is normally not needed
within a Vaadin Flow application's high-level components.Deprecated, for removal: This API element is subject to removal in a future version.
Use
NativeLabelElement instead.Language object.
Abstract base class for all map layers
The layout of the legend items.
DataView for lazy loaded data.
The legend is a box containing a symbol and name for each series item or
point item in the chart.
Options for the paging or navigation appearing when the legend is overflown.
Style options for Legend
A title to be added on top of the legend.
Serializer for
LegendTitle.Set options on specific levels.
Event that is fired during license lifecycle, e.g.
The license event type.
Event handler that gets notified on license events.
The interface to store license usage data.
Implementation of
GenericVisitor
that finds Node at given line of source code file.Linux /proc file reader.
Change describing an add operation in a
list node feature.List Box allows the user to select one or more values from a scrollable list
of items.
Base class for the
ListBox and MultiSelectListBox.Implementation of generic data view for ListBox.
A TestBench element representing a
<vaadin-list-box>
element.Data view implementation for ListBox with in-memory list data.
Tester for ListBox components.
Event that is fired when the value in a collaboration list changes.
Change describing a clear operation in a
list node feature.DataProvider wrapper for Collections.DataView for a in-memory list data that provides information on the data and
allows operations on it.
This annotation sets the priority of execution on
BeforeEnterListeners, BeforeLeaveListeners and
AfterNavigationListeners.Component representing a
<li> element.A TestBench element representing a
<li> element.An object which identifies each item of a
CollaborationList.A list operation providing details such as the operation type, related
properties and conditions that should be met for the operation to succeed.
The result of a list operation in a
CollaborationList.Change describing a remove operation in a
list node feature.A series consisting of a list of numerical values.
Event handler that gets notified for changes to collaboration lists.
LitRenderer is a
Renderer that uses a Lit-based template literal to
render given model objects in the components that support the JS renderer
functions API.Component which renders a LitElement template.
Template initialization related logic.
Lit template content parser.
Lit template parser factory.
Wrapper for the parsing result.
Lit template parser implementation.
Defines routes to load eagerly.
The loading options control the appearance of the loading screen that covers
the plot area on chart operations.
Provides method for configuring the loading indicator.
Map for storing configuration for the loading indicator.
Determines a way that dependency is loaded.
A simple backend implementation that only distributes events locally and
assumes that there is no previous history for event logs.
Implementation of
GenericVisitor
that searches for classnames applied to given component.Implementation of
GenericVisitor
that searches for local classname expression statement by comparing
expression type, method call scope and expression comment.A renderer for presenting date values.
A renderer for presenting
LocalDateTime objects.A converter that converts between
LocalDateTime and
Date.A converter that converts between
LocalDateTime and
Instant.A converter that converts between
LocalDate and
Date.Event object with data related to locale change.
Any
com.vaadin.ui.Component implementing this interface will be
informed when the UI locale is changed and on attach.Utility class for locale handling.
Represents a relative URL made up of path segments and query parameters, but
lacking e.g.
Event created when the location changes by any of the reasons defined at
NavigationTrigger.Utility class exposing reusable utility methods for location.
Login is a component that contains a login form.
TestBench element for the
<vaadin-login-form> elementTester for LoginForm components.
Internationalization object for customizing the component UI texts.
I18n properties for the error message.
I18n properties for the form.
I18n properties for the header.
Server-side component for the
<vaadin-login-overlay> component.Class for adding and removing components to the custom form area of the
overlay.
Class for adding and removing components to the footer area of the
overlay.
TestBench element for the
<vaadin-login-overlay> elementTester for LoginOverlay components.
A
PerRequestBroadcastFilter implementation that handles
AtmospherePushConnection.PushMessages
to ensure that a message is preserved in the BroadcasterCache until
the client has received it.Validator for validating that an
Long is inside a given range.Provides a way to discover services used by Flow (SPI).
Default implementation of
AbstractLookupInitializer.Default implementation of
AppShellPredicate.Default implementation of
Lookup.Default implementation of
ResourceProvider.Standard servlet initializer for collecting all SPI implementations.
Lumo component theme class implementation.
The dark version of the default theme for Vaadin Charts.
Enumeration of all icons in the
Lumo Icons
collection.
The default theme for Vaadin Charts.
Contains the definition for all the CSS utility classes provided by Lumo.
Accessibility related classes.
Classes for distributing space around and between items along a flexbox’s
cross axis or a grid’s block axis.
Classes for aligning items along a flexbox’s cross axis or a grid’s block
axis.
Classes for overriding individual items' align-item property.
Classes for applying a background color.
Border-related classes.
Classes for setting the border color of an element.
Classes for setting the border radius of an element.
Classes for applying a box shadow.
Classes for setting the box sizing property of an element.
Classes for setting the display property of an element.
Set of classes with styles to be used for certain viewport sizes
Classes for defining the display property of an element that will
be applied when the viewport has a minimum width of 1024px
Classes for defining the display property of an element that will
be applied when the viewport has a minimum width of 768px
Classes for defining the display property of an element that will
be applied when the viewport has a minimum width of 640px
Classes for defining the display property of an element that will
be applied when the viewport has a minimum width of 1280px
Classes for defining the display property of an element that will
be applied when the viewport has a minimum width of 1536px
Classes for setting how items grow and shrink in a flexbox layout.
Classes for setting the flex direction of a flexbox layout.
Set of classes defining the flex direction of an element that will be
applied only for certain viewport sizes.
Classes that will be applied when the viewport has a minimum
width of 1024px.
Classes that will be applied when the viewport has a minimum
width of 768px.
Classes that will be applied when the viewport has a minimum
width of 640px.
Classes that will be applied when the viewport has a minimum
width of 1280px.
Classes that will be applied when the viewport has a minimum
width of 1536px.
Classes for setting how items wrap in a flexbox layout.
Classes for setting the font size of an element.
Set of classes defining the font size of an element that will be
applied only for certain viewport sizes.
Classes that will be applied when the viewport has a minimum
width of 1024px.
Classes that will be applied when the viewport has a minimum
width of 768px.
Classes that will be applied when the viewport has a minimum
width of 640px.
Classes that will be applied when the viewport has a minimum
width of 1280px.
Classes that will be applied when the viewport has a minimum
width of 1536px.
Classes for setting the font weight of an element.
Classes for defining the space between items in a flexbox or grid layout.
Classes for defining the horizontal space between items in a flexbox
or grid layout.
Classes for defining the vertical space between items in a flexbox or
grid layout.
Set of classes to define the content flow on a grid layout.
Set of classes defining the number of columns in a grid layout that
will be applied only for certain viewport sizes.
Classes that will be applied when the viewport has a minimum
width of 1024px.
Classes that will be applied when the viewport has a minimum
width of 768px.
Classes that will be applied when the viewport has a minimum
width of 640px.
Classes that will be applied when the viewport has a minimum
width of 1280px.
Classes that will be applied when the viewport has a minimum
width of 1536px.
Classes for setting the number of columns in a grid layout.
Classes for setting the number of rows in a grid layout.
Classes for defining the height of an element.
Classes for defining the size of elements used as icons.
Classes for aligning items along a flexbox’s main axis or a grid’s inline
axis.
Classes for setting the line height of an element.
Class for removing the default look of a list.
Classes for setting the margin of an element.
Classes for setting the bottom margin of an element.
Classes for setting the logical inline end margin of an element.
Classes for setting both the left and the right margins an element.
Classes for setting the left margin of an element.
Classes for setting the right margin of an element.
Classes for setting the logical inline start margin of an element.
Classes for setting the top margin of an element.
Classes for setting both the top and the bottom margins of an
element.
Classes for defining the maximum height of an element.
Classes for defining the maximum width of an element.
Classes for defining the minimum height of an element.
Classes for defining the minimum width of an element.
Classes for setting the overflow behavior of an element.
Classes for setting the padding of an element.
Classes for setting the bottom padding of an element.
Classes for setting the logical inline end padding of an element.
Classes for setting both the right and left paddings of an element.
Classes for setting the left padding of an element.
Classes for setting the right padding of an element.
Classes for setting the logical inline start padding of an element.
Classes for defining the top padding of an element.
Classes for defining both the vertical and horizontal paddings of an
element.
Classes for setting the position of an element.
Classes for setting an element’s text alignment.
Classes for setting an element’s text color.
Classes for setting the text overflow.
Classes for transforming the text.
Classes for setting how the white space inside an element is handled.
Classes for setting the width of an element.
Component representing a
<main> element.Map is a component for displaying geographic maps from various sources.
Base class for the map component.
Event that is fired when the value in a collaboration map changes.
Representing OpenLayers' @code{click} event
Provides data for click events on geographic features
Provides data for when a feature is dropped after a drag operation
Change describing a changed value in a map feature.
Change describing a value removed from a map.
Custom JSON serializer for the map component using a Jackson
ObjectMapperEvent handler that gets notified for changes to collaboration maps.
Model map synchronization RPC handler.
Set of theme variants applicable for the
vaadin-map component.Fired when viewport movement has ended.
In Highcharts 1.0, the appearance of all markers belonging to the hovered
series.
A convenience class for displaying icons or images, such as markers, at a
specific location on the map.
Marker style
Interface for all marker symbols
A predefined shape or symbol for the marker.
Symbol that is fetched from the url, implementing ChartEnum to provide
correct serialization
Material component theme class implementation.
Utilities for Maven based projects.
The event dispatched when a node joins or leaves the backend.
The type of the event.
A listener of
MembershipEvent.Basic in memory file receiver implementation.
Menu Bar is a horizontal button bar with hierarchical drop-down menus.
The internationalization properties for
MenuBarA TestBench element representing a
<vaadin-menu-bar>
element.Tester for MenuBar components.
Set of theme variants applicable for
vaadin-menu-bar component.Item component used inside
ContextMenu and SubMenu.MenuItemBase<C extends ContextMenuBase<C,I,S>,I extends MenuItemBase<C,I,S>,S extends SubMenuBase<C,I,S>>
Base class for item component used inside
ContextMenus.A class which is utilized internally by components such as context menu and
menu bar.
Common management logic for context menus and sub menus.
Utility class for common
MessageDigest operations.A TestBench element representing a
<vaadin-message>
element.Functional interface that defines how to handle a message when it is added to
a topic.
The context of the message.
Message Input allows users to author and send messages.
The
submit event which is fired by MessageInput
component.A TestBench element representing a
<vaadin-message-input>
element.The internationalization properties for
MessageInput.Tester for MessageInput components.
Message List allows you to show a list of messages, for example, a chat log.
A TestBench element representing a
<vaadin-message-list>
element.Item to render as a message component inside a
MessageList.Tester for MessageList components.
Manager to handle messages sent to a topic.
Defines a meta tag with customized name and content that will be added to the
HTML of the host page of a UI class.
Internal annotation to enable use of multiple
Meta annotations.Serializes miscellaneous metadata to JSON.
Class for setting any down meta keys for events supporting meta keys.
Makes sure that the
MockSpringServlet.routes are properly registered, and that
MockSpringServletService is used instead of vanilla
SpringVaadinServletService.A mocking service that performs three very important tasks:
Overrides
MockSpringServletService.isAtmosphereAvailable() to tell Vaadin that we don't
have Atmosphere (otherwise Vaadin will crash)
Provides some dummy value as a root ID via MockSpringServletService.getMainDivId(com.vaadin.flow.server.VaadinSession, com.vaadin.flow.server.VaadinRequest)
(otherwise the mocked servlet env will crash).
Provides a MockSpringVaadinSession instead of
SpringVaadinSession.
The class is intentionally opened, to be extensible in user's library.A Vaadin Session with one important difference:
Creates a new session when this one is closed.
An adapter to make a generic Spring ApplicationContext act like a
WebApplicationContext.
The mode the application is running in.
List for model values used in data binding in templates.
Enums for mouse button values in click events.
Helper class to store and transfer mouse event details.
Helper class to store and transfer mouse event details.
Constants for mouse buttons.
Constants for mouse buttons.
Basic receiver implementation for receiving multiple file upload and storing
them as files.
Basic multi file in memory file receiver implementation.
Interface that must be implemented by the upload receivers to provide the
Upload component an output stream to write the uploaded data.
Multi selection component which allows to select and deselect multiple items.
MultiSelectComboBox allows the user to select one or more values from a
filterable list of options presented in an overlay.
A TestBench element representing a
<vaadin-multi-select-combo-box> element.Class for localization of the
MultiSelectComboBoxSet of theme variants applicable for
vaadin-multi-select-combo-box
component.Fired when the selection changes in a listing component that supports
multiple item selection.
A listener for listening for selection changes from a multiselection
component.
Server-side component for the
vaadin-list-box element with
multi-selection.Tester for MultiSelectListBox components.
Component representing a
<button> element.A TestBench element representing a
<button> element.A renderer to create a clickable button.
Component representing a
<details> element.Component representing a
<summary> element.Represents the DOM event "toggle".
A TestBench element representing a
<details> element.Component for a
<label> element, which represents a
caption for an input field in a user interface.A TestBench element representing a
<label> element.Component representing a
<nav> element.A collection of options for buttons and menus appearing in the exporting
module.
Event object with data related to navigation.
Handles navigation to a location e.g.
Contains the information resulted from searching a route target using a
navigation url as input.
RPC handler for Navigation.
Contains all relevant information related to a valid navigation.
A builder class for constructing new
NavigationState instances.Handles navigation events by rendering a contained NavigationState in the
target UI.
A filter that can prevent specific navigation targets from being registered.
The type of user action that triggered navigation.
The navigator is a small series below the main series, displaying a view of
the entire data set.
Utility class for network related methods.
Options for displaying a message like "No data to display".
A collection of options for the individual nodes.
Represents a node in the DOM.
Change describing that a node has been attached.
Base class describing a change to a state node.
Change describing that a node has been detached.
A node feature represents a group of related values and functionality in a
state node.
Base class for all node changes related to a feature.
A registry of node features that are available based on type.
Registry of node feature id numbers and map keys shared between server and
client.
Node installation class.
A state node feature that structures data as a list.
A state node feature that structures data as a map.
Abstract root of a state node tree.
Various node properties' ids.
A series containing nodes and links to nodes.
Data for the
NodeSeries.An executor that it's run when the servlet context is initialised in dev-mode
or when flow-maven-plugin goals are run.
Base abstract class for frontend updaters that needs to be run when in
dev-mode or from the flow maven plugin.
A node feature that carries a single value.
Element API node visitor interface.
The type of the element.
FailedEvent that indicates that an input stream could not be obtained.
Exception for when there is no
InputStream available.FailedEvent that indicates that an output stream could not be obtained.
Exception for when there is no
OutputStream available.Exception indicating that something went wrong while resolving navigation
routes.
A marker annotation to avoid applying any default theme to the application.
Notifications are used to provide feedback to the user.
opened-changed event is sent when the notification opened state
changes.Enumeration of all available positions for notification component
A TestBench element representing a
<vaadin-notification>
element.Tester for Notification components.
Set of theme variants applicable for
vaadin-notification component.Methods annotated with
NotSupported are mapped to the original
webcomponent implementation, but not supported at Java level.Annotation for defining an npm package dependency on a
Component
class which includes one or more JS modules.Internal annotation to enable use of multiple
NpmPackage
annotations.A stateless singleton node owner that is used for nodes that have not yet
been attached to a state tree.
Number Field sports many of the same features as Text Field but only accepts
numeric input.
A TestBench element representing a
<vaadin-number-field>
element.Tester for NumberField components.
A renderer for presenting number values.
A DataSeriesItem implementation suitable for <a
https://en.wikipedia.org/wiki/Open-high-low-close_chart">OHLC charts.
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.Util for opening a file in the currently used IDE.
Marks a Navigation url parameter as optional.
Build a
NodeExecutor instance.Options to render charts in 3 dimensions.
Component representing a
<ol> element.Defines the numbering type of the list items.
A TestBench element representing an
<ol> element.Map source for loading tiled images from an OpenStreetMap service.
Internal class that provides shared functionality for setting CSS class names
to overlay only components that support
HasStyle, such as
Dialog.Represents the web page open in the browser, containing the UI it is
connected to.
Callback for receiving extended client-side details.
DataCommunicator implementation which disables the paging and does not allow
the user to set up the page for VirtualList.
Defines the HTML page title for a navigation target.
Generic class representing an immutable pair of values.
Applies only to polar charts and angular gauges.
Pane Container to allow multiple Panes
Serializer for
PaneListAllows setting a key to switch between zooming and panning.
Component representing a
<p> element.A TestBench element representing a
<p> element.This runner is loosely based on FactoryTestRunner by Ted Young
(http://tedyoung.me/2011/01/23/junit-runtime-tests-custom-runners/).
JUnit scheduler capable of running multiple tets in parallel.
Unit tests should extend
ParallelTest if they are to be run in
several browser configurations.Test suite which consists of all the TestBench tests passed in the
constructor.
Component representing a
<param> element for
<param> element.Parameter deserialization utility.
Defines the parent layout for components in routing hierarchy.
Immutable parser data which may be stored in cache.
PartialFill configuration object to be used in
PlotOptionsXrange.Password Field is an input field for entering passwords.
A TestBench element representing a
<vaadin-password-field>
element.Utility class which contains various methods for parsing a route url into
segments.
A pending JavaScript result that can be sent to the client.
A pending result from a JavaScript snippet sent to the browser for
evaluation.
Exception used when a
CompletableFuture returned from
PendingJavaScriptResult is completed exceptionally because of a
client-side error.
Options for the pivot or the center point of the gauge.
Platform contains information about system architecture and OS.
Provides information about the current version of Vaadin Platform.
An array of objects defining plot bands on the Y axis.
An array of lines stretching across the plot area, marking a specific value
on one of the axes.
The area range is a cartesian series type with higher and lower Y values
along an X axis.
The area spline range is a cartesian series type with higher and lower Y
values along an X axis.
A box plot is a convenient way of depicting groups of data through their
five-number summaries: the smallest observation (sample minimum), lower
quartile (Q1), median (Q2), upper quartile (Q3), and largest observation
(sample maximum).
A bubble series is a three dimensional series type where each point renders
an X, Y and Z value.
Plot options for
ChartType.BULLET charts.The column range is a cartesian series type with higher and lower Y values
along an X axis.
Error bars are a graphical representation of the variability of data and are
used on graphs to indicate the error, or uncertainty in a reported
measurement.
Funnel charts are a type of chart often used to visualize stages in a sales
project, where the top are the initial stages with the most clients.
General plotting options for the gauge series type.
The heatmap series type.
Plot options for
ChartType.ORGANIZATION charts.A pie chart is a circular chart divided into sectors, illustrating numerical
proportion.
A polygon series can be used to draw any freeform shape in the cartesian
coordinate system.
A pyramid chart consists of a single pyramid with item heights corresponding
to each point value.
General options for all series types.
A gauge showing values using a filled arc with colors indicating the value.
Styles for PlotOptions of different plot types
Plot options for
ChartType.TIMELINE charts.The size of the point shape is determined by its value relative to its
siblings values.
Options for the waterfall series type.
Options for the xrange series type.
Geometry that is represented by a single point and coordinate.
Abstract base class for features that are represented by a single point and a
single coordinate.
The PointClickEvent class stores data for click events on the points of the
chart.
The PointLegendItemClickEvent class stores information on click events on the
charts's legend items that correspond to a chart point.
Fired when the mouse exits the neighborhood of a point
Fired when the mouse pointer moves within the neighborhood of a point
Possible values: null, ON, BETWEEN.
The PointRemoveEvent class stores data for remove events on the points of the
chart
The PointSelectEvent class stores data for select events on the points of the
chart.
The PointUnselectEvent class stores data for unselect events on the points of
the chart.
The PointUpdateEvent class stores data for update events on the points of the
chart
A node map for storing configuration for polling.
An event that is fired whenever a client polls the server for asynchronous UI
updates.
The interface for adding and removing
PollEvent listeners.Map of PolymerTemplate events with server-side listeners.
Deprecated.
Polymer template support is deprecated - we recommend you to use
LitTemplate instead.Position configuration for the credits label.
Container class for containing left over listeners on postponed navigation.
Component representing a
<pre> element.A TestBench element representing a
<pre> element.Functional interface that defines how to handle user presence changes in a
topic.
The context of the user presence.
Manager to handle user presence in topics.
Indicates that a previous view instance should be-reused when reloading a
location in the same browser window/tab.
Progress Bar shows the completion status of a task or process.
A TestBench element representing a
<vaadin-progress-bar>
element.Set of theme variants applicable for
vaadin-progress-bar component.ProgressListener receives events to track progress of upload.
ProgressUpdateEvent is sent to track progress of upload.
Defines constants for map coordinate projections.
The exception is thrown when a property change from client is disallowed on
the server side.
An event fired when the value of a property changes.
Functional interface that defines how to handle value changes for properties
in a topic.
The property change event.
A listener for property change events.
Offers a fluent API for configuring the properties of embedded web components
produced by
WebComponentExporter.For internal use only.
Value object containing information of a web component's property field.
A property from a
PropertySet.The property handling implementation of
DeploymentConfiguration based
on a base class for resolving system properties and a set of init parameters.Describes a component property that has its value stored in some form in the
component's element, typically an element property or attribute.
Factory methods for creating
PropertyDescriptor instances.Contains the constraints for filtering nested properties.
Defines the custom property name to be bound to a
field
component using Binder.Describes a set of properties that can be used for configuration based on
property names instead of setter and getter callbacks.
Proxy configuration used for downloads and executions.
Class for holding proxy information.
RPC handler for events triggered through
element.$server or
simply $server in template event handlers.Configures automatic server push.
Handles Atmosphere requests and forwards them to logical methods in
PushHandler.Provides method for configuring the push channel.
Map for storing the push configuration for a UI.
Map for storing push parameters.
Represents a bidirectional ("push") connection between a single UI and its
client-side.
Factory that produces instances of
PushConnection.Shared constants used by push.
Handles incoming push connections and messages and dispatches them to the
correct
UI/ AtmospherePushConnection.The mode of bidirectional ("push") communication that is in use.
Handles requests to open a push (bidirectional) communication channel between
the client and the server.
Defines application PWA properties.
Holds the configuration from the
PWA annotation.Handles serving of PWA resources.
Implementation of icons used in PWA resources.
Place where icon belongs to (header or manifest.webmanifest).
Registry for PWA data.
Immutable query object used to request data from a backend.
Holds query parameters information.
Sorting information for
Query.Helper classes with fluent API for constructing
QuerySortOrder lists.A TestBench element representing a
<vaadin-radio-button>
element.Radio Button Group allows the user to select exactly one value from a list of
related but mutually exclusive options.
Implementation of generic data view for RadioButtonGroup.
A TestBench element representing a
<vaadin-radio-button-group> element.Data view implementation for RadioButtonGroup with in-memory list data.
Tester for RadioButtonGroup components.
Tester for RadioButton components.
Set of theme variants applicable for
vaadin-radio-group component.An immutable representation of a range, marked by start and end points.
The range selector is a tool for selecting ranges to display within the
chart.
Options for range selector buttons.
Possible timespan values for range selector buttons
Series for range type data
Verifies that a value is within the given range.
Generic
HasValue to use any type of component with Vaadin data
binding.Interface that must be implemented by the upload receivers to provide the
Upload component an output stream to write the uploaded data.
Provides methods for configuring the reconnect dialog.
Map for storing the reconnect dialog configuration for a UI.
ReferenceImageRepresentation contains a block representation of a reference
image.
Generates the name of a reference screen shot from a string ID and browser
information.
A thread-safe cache for the result of doing some reflection lookup based on a
class.
An util class with helpers for reflection operations.
A string validator comparing the string against a Java regular expression.
A registration object for removing an event listener added to a source.
Base class for all renderers - classes that take a given model object as
input and handles their rendering to the client side when requested.
Defines the context of a given
Renderer when building the output
elements.Handler for producing a response to HTTP requests.
Contains utility methods related to request handling.
This interface represents a predicate which returns
true if bound
field should be configured to have required indicator via
HasValue.setRequiredIndicatorVisible(boolean).Helper methods used by
RequiredFieldConfigurator.The button that appears after a selection zoom, allowing the user to reset
zoom.
What frame the button should be placed related to.
An object used to encapsulate data used in resolving routing requests.
Static "classpath" resources provider.
The class that handles writing the response data into the response.
Allows setting a set of rules to apply for different screen or chart sizes.
Represents the result of an operation that might fail, such as type
conversion.
A retry rule is used to re-run a test several times in case of a random
failure.
RPC handler for return channel messages.
Server-side node feature that keeps track of the return channels registered
for a state node.
A registration for a return channel.
Rich Text Editor is an input field for entering rich text.
The internationalization properties for
RichTextEditor.Set of theme variants applicable for
vaadin-rich-text-editor
component.Condition to check whether the Vaadin servlet is mapped to the root
("/*").
Defines the route template suffix for components that function as navigation
targets in routing.
Defines the route alias for components that function as navigation targets in
routing.
Internal annotation to enable use of multiple
RouteAlias
annotations.Route data for an 'alias' route.
Abstract base class for route and route alias data.
Route configuration helper class for adding, removing and reading routes from
the different registries.
Data collection of information for a specific registered route target.
This is a basic default error view shown on routing exceptions.
Route parameter containing the name and the value used mainly when
constructing a
RouteParameters instance.Immutable data representing one url parameter.
Define the route parameters format flags.
Predefined regex used with template parameters.
Immutable container which stores the route parameters extracted from a
navigation url received from the client.
Allows to implement a custom navigation target path generation logic for
components annotated with
@Route(Route.NAMING_CONVENTION).Defines the route prefix that a Parent layout adds to a route when used in
the active view chain.
The router takes care of serving content when the user navigates within a
site or an application.
The RouteRegistry interface class that gives the out facing usage needs for a
route registry implementation.
Servlet initializer for collecting all available
Routes on startup.Callback interface for resolving
ResolveRequests to new
NavigationStates.Implementations of this interface represent a parent for a navigation target
components via the
Route.layout() parameter.A link that handles navigation internally using
Router instead of
loading a new page in the browser.Result class containing the removed and added routes for the latest
configuration.
Listener that gets notified when the registered routes for a
RouteRegistry are changed in some way.The lifecycle of a
@RouteScope bean is controlled by route
navigation.Link a
@RouteScope bean to its owner.Route target stores the target component and parent layouts.
Utility class with methods for route handling.
Row class to define rows used in a
Board instance.This class represents one row inside the Vaadin Board.
Thrown if RPC method argument cannot be decoded to the required type.
Decoder of RPC method arguments (server-side methods invoked from the
client-side).
RPC invocation handler interface.
A set of rules for responsive settings.
Marks this testcase to run locally.
Can receive a parameter to define which browser and version to run the test on.
Can receive a parameter to define which browser and version to run the test on.
Test classes annotated with RunOnHub will be run on the hub whose host is
defined by its value.
Integration methods for Sauce Labs testing.
Sauce Labs specific remote webdriver capabilities
This JUnit
Rule grabs a screenshot when a test fails.
An optional scrollbar to display on the Y axis in response to limiting the
minimum an maximum of the axis values.
Scroller is a component container which enables scrolling overflowing
content.
Enum for the values of the ScrollDirection property.
A TestBench element representing a
<vaadin-scroller>
element.Set of theme variants applicable for
vaadin-scroller component.Options for scrollIntoView.
Alignment for scrollIntoView.
Scroll behavior for scrollIntoView.
Component representing a
<section> element.The appearance of the point marker when selected.
Select allows users to choose a single value from a list of options presented
in an overlay.
invalid-changed event is sent when the invalid state changes.opened-changed event is sent when the overlay opened state
changes.Implementation of generic data view for
Select.A TestBench element representing a
<select> element.Testbench Element API for vaadin-select.
A selection event that unifies the way to access to selection event for multi
selection and single selection components (in case when only one selected
item is required).
A listener for
SelectionEvent.Models the selection logic of a
Listing component.A selection model in which multiple items can be selected at the same
time.
A selection model in which at most one item can be selected at a time.
Data view implementation for
Select with in-memory list data.Set of theme variants applicable for
vaadin-select component.A
BiConsumer that is also Serializable.A
BiFunction that is also Serializable.A
BiPredicate that is also Serializable.A
Comparator that is also Serializable.A
Consumer that is also Serializable.Event listener interface that is serializable.
A
Function that is also Serializable.A list which contains
Serializable values but not StateNodes.A
Predicate that is also Serializable.A
Runnable that is also Serializable.A
Supplier that is also Serializable.Like
SerializableBiConsumer, but with three arguments.Series interface for all kinds of Series
Event for information about a new series to be added
Fired after a chart series is animated
Event for information about changes in data of series
SeriesCheckboxClickEvent triggered when a checkbox in a legend is clicked
The SeriesClickEvent class stores data for click events on the series of the
chart.
Fired when a series is hidden
The SeriesLegendItemClickEvent class stores information on click events on
the charts's legend items that correspond to a chart series.
Fired when the mouse exits the neighborhood of a series
Fired when the mouse moves within the neighborhood of a series
Fired when a series is shown
Listener class for Series enabling and disabling events.
A configuration object for the tooltip rendering of each single series.
Data for a info message to the debug window.
Handles a client-to-server message containing serialized RPC invocations.
Exception thrown then the security key sent by the client does not match
the expected one.
Exception thrown then the client side resynchronization is required.
A data transfer object representing an RPC request sent by the client
side.
Abstract node feature that is only present on the server.
A URI resolver which resolves paths for loading through VaadinService
resource methods.
Event fired to
ServiceDestroyListener when a VaadinService is
being destroyed.Listener that gets notified when the
VaadinService to which it has
been registered is destroyed.Thrown for problems which occur in the
VaadinService layer.Event fired to
VaadinServiceInitListener when a VaadinService
is being initialized.All ServletContextListeners in Flow merged into one actual listener to be
able to control the order they are executed in.
Context listener that automatically registers Vaadin servlets.
Event fired when a Vaadin service session is no longer in use.
A listener that gets notified when a Vaadin service session is no longer
used.
Exception indicating that the session has expired.
A specialized RequestHandler which is capable of sending session expiration
messages to the user.
Event gets fired when a new Vaadin service session is initialized for a
Vaadin service.
Event listener that can be registered to a
VaadinService to get an
event when a new Vaadin service session is initialized for that service.Handles a request by passing it to each registered
RequestHandler in
the session in turn until one produces a response.SessionRouteRegistry is a mutable route registry that is valid in the scope
of VaadinSession.
The function to write the field value to the bean property
Represents a shadow dom root of an element.
Map of basic element information.
Marker feature for a
StateNode which is a shadow root for some
element.Implementation which handles shadow root nodes.
The name of a symbol to use for the border around the
Datalabels or
Tooltip.Misc internal utility methods used by both the server and the client package.
Copied from Flow to avoid a dependency.
Event when shortcut is detected.
Listener for shortcut events.
A registration object for both configuring and removing the registered
keyboard shortcut.
Collections of methods for configuring more complex Shortcut interactions.
Validator for validating that an
Short is inside a given range.
Note: As of v5.0.12,
frame.left or frame.right
should be used instead.A side navigation menu with support for hierarchical and flat menus.
The internationalization properties for
SideNav.A menu item for the
SideNav component.Abstract base class for geometries
Single selection component whose selection is treated as a value.
Fired when the selection changes in a listing component.
A listener for listening to selection changes on a single selection
component.
Util methods for handling child elements inside slots.
Solid (non gradient) colors
Serializer for
SolidColorDescribes sorting direction.
Event describing a change in sorting of a
DataProvider.The interface for adding and removing listeners for
SortEvents.Sorting information for one field.
Base class for helper classes with fluent API for constructing sort order
lists.
Generates the sort orders when rows are sorted by a column.
Abstract base class for all map sources
Component representing a
<span> element.A TestBench element representing a
<span> element.Split Layout is a component with two content areas and a draggable split
handle between them.
numeration of all available orientation for VaadinSplitLayout component
A TestBench element representing a
<vaadin-split-layout>
element.Set of theme variants applicable for
vaadin-split-layout component.Passes Spring application properties to the Vaadin application configuration.
Spring boot auto-configuration class for Flow.
Convenience alias for
Component to
prevent conflicts with Component.A pojo for Spring CSRF token.
A util class for helping dealing with Spring CSRF token.
Sets Spring Boot dev tools to run on a free random port if the default port
(35729) is in use.
Default Spring instantiator that is used if no other instantiator has been
registered.
Spring aware
LookupInitializer implementation.Spring boot auto-configuration class for Flow.
Configures mock request with authentication details from Spring Security.
Spring application context aware Vaadin servlet implementation.
Base JUnit 4 class for UI unit testing applications based on Spring
Framework.
Helpers related to Spring.
Spring application context aware Vaadin servlet service implementation.
Vaadin session implementation for Spring.
A Spring specific view access checker that falls back to Spring mechanisms
when the generic mechanisms do not work.
Whether to stack the values of each series on top of each other.
The stack labels show the total value for each bar in a stacked column or bar
chart.
StartedEvent event is sent when the upload is started to received.
Implementation of
GenericVisitor
that finds Statement at given line of source code file.A node in the state tree that is synchronized with the client-side.
A list which contains
StateNodes.The state tree that is synchronized with the client-side.
A task to be executed before the client response, together with an
execution sequence number and context object.
A registration object for removing a task registered for execution before
the client response.
Handler for static files.
A factory to create a
StaticFileHandler.Handles sending of resources from the WAR root (web content) or
META-INF/resources in the case that
VaadinServlet is mapped using
"/*".Constants for development mode statistics.
Wraps a JSON data structure and provides a slightly easier API for it.
Handles sending of telemetry data.
Development more usage statistic storage and methods for updating the data.
Binder status change event.
Listener interface for status change events from binder.
Utility class around the time picker steps functionality.
Defines different step line types.
Serializer for
Stop.Implementation of
StreamVariable.StreamingEndEvent.Implementation for
StreamVariable.StreamingErrorEvent.Implementation for
StreamVariable.StreamingProgressEvent.Implementation for
StreamVariable.StreamingStartEvent.Represents a receiver for data upload from the client.
Handles
StreamReceiver instances registered in VaadinSession.An UploadInterruptedException will be thrown by an ongoing upload if
StreamVariable.isInterrupted() returns true.Stream registration result.
Represents dynamically generated data.
Handles
StreamResource instances registered in VaadinSession.Registry for
StreamResource instances.Output stream consumer.
StreamVariable is a special kind of variable whose value is streamed to an
OutputStream provided by the StreamVariable.getOutputStream() method.Event passed to
StreamVariable.streamingFinished(StreamingEndEvent) method the
contents have been streamed to StreamVariable successfully.Event passed to
StreamVariable.streamingFailed(StreamingErrorEvent) method when
the streaming ended before the end of the input.Streaming event interface.
Event passed to
StreamVariable.onProgress(StreamingProgressEvent) method during
the streaming progresses.Event passed to
StreamVariable.streamingStarted(StreamingStartEvent) method
before the streaming of the content to StreamVariable starts.Verifies that the length of a string is within the given range.
A converter that converts from
String to BigDecimal and back.A converter that converts from
String to BigInteger and back.Utility class for special string handling.
Style options for CSS styling
Defines how to visually represent a
FeatureProvides inline styles for
Elements.Css values for the clear property.
Css values for the float property.
Css values for the position property.
Css values for the text-align property.
Css values for the visibility property.
Css values for the white-space property.
Emulates the
style attribute by delegating to
Element.getStyle().CSS position attribute, ABSOLUTE or RELATIVE
Defines style sheet dependencies on a
Component class.Internal annotation to enable use of multiple
StyleSheet
annotations.Utility methods for
Style.Helper class when JSON structure needs object with just style field
API that allows adding content into the sub menus of a
ContextMenu to
create hierarchical menus.SubMenuBase<C extends ContextMenuBase<C,I,S>,I extends MenuItemBase<C,I,S>,S extends SubMenuBase<C,I,S>>
Base class for sub-menus in
ContextMenuBase extensions.The chart's subtitle
SucceededEvent event is sent when the upload is received successfully.
A component that displays a given SVG image.
Component for displaying an icon from a SVG file.
Annotates getters for which properties should be synchronized to the server.
RequestHandler which takes care of locking and unlocking of the VaadinSession
automatically.
A connection context that is always active.
Contains the system messages used to notify the user about various critical
situations that can occur.
Provides information available for
SystemMessagesProvider when
defining what SystemMessages to use.Gives out system messages based on Locale.
A
UserInfo for non-interaction thread.This component provides an accessible and customizable tab to be used inside
Tabs component.A TestBench element representing a
<vaadin-tab> element.Tabs are used to organize and group content into sections that the user can
navigate between.
The valid orientations of
Tabs instances.An event to mark that the selected tab has changed.
A TestBench element representing a
<vaadin-tabs> element.TabSheet consists of a set of tabs and the content area.
An event to mark that the selected tab has changed.
A TestBench element representing a
<vaadin-tabsheet>
element.Set of theme variants applicable for
vaadin-tabsheet component.Tester for Tabs components.
Set of theme variants applicable for
vaadin-tabs component.Set of theme variants applicable for
vaadin-tab component.Defines the tag to use for the root element for a component created using the
default
Component constructor.Page target element enum for inlining during bootstrap creation.
Set options related with look and position of targets.
Clean any frontend files generated for creation on a new development or
production bundle.
Copies JavaScript and CSS files from JAR files into a given folder.
Copies JavaScript files from the given local frontend folder.
Copies template files to the target folder so as to be available for parsing
at runtime in production mode.
A task for generating the bootstrap file
FrontendUtils.BOOTSTRAP_FILE_NAME during `package` Maven goal.Generate the TS files for endpoints, and the Client API file.
A task for generating the feature flags file
FrontendUtils.FEATURE_FLAGS_FILE_NAME during `package` Maven goal.Generate
index.html if it is missing in frontend folder.Generate
index.ts if it is missing in frontend folder.Generate OpenAPI json file for Vaadin Endpoints.
Creates the
package.json if missing.Generate
index.html if it is missing in frontend folder.Generate
tsconfig.json if it is missing in project folder.Generate
types.d.ts if it is missing in project folder and
tsconfig.json exists in project folder.Generate
vite-devmode.ts if it is missing in frontend/generated
folder.A task for generating the bootstrap file for exported web components
FrontendUtils.WEB_COMPONENT_BOOTSTRAP_FILE_NAME during `package`
Maven goal.Generate
web-component.html if it is missing in frontend folder.Task that installs any Flow webpack plugins into node_modules/@vaadin for use
with webpack compilation.
Copies production bundle files from pre-compiled bundle JAR into a folder
where production bundle is normally located.
Compiles the dev mode bundle if it is out of date.
Run
npm install after dependencies have been updated.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.Updated
index.ts if it imports Flow from an old location.Updates
package.json by visiting NpmPackage annotations
found in the classpath.Creates a vaadin-dev-server-settings.json file for use with dev server
configuration.
Task generating the theme definition file 'theme.js' for importing
application theme into the generated frontend directory.
Updates the Vite configuration files according with current project settings.
Marker interface for (Lit and Polymer) templates.
Interface used to create
DesiredCapabilities configurations suitable
for test cases.Provides actual implementation of TestBenchCommands
TestBenchElement is a WebElement wrapper.
A superclass with some helpers to aid TestBench developers.
Sets the category of a test class.
Categories can be excluded from running tests, or explicitly included.
Categories can be excluded from running tests, or explicitly included.
Defines a system property to be used as part of the test name.
It may be useful to add information related to the system or the machine itself, such as the OS.
This will affect, for instance, the names of screenshots taken in case of test failure.
It may be useful to add information related to the system or the machine itself, such as the OS.
This will affect, for instance, the names of screenshots taken in case of test failure.
Wrapper annotation for indicating which components a wrapper implementation
supports.
A component which encapsulates the given text in a text node.
The text alignment for the label.
Text Area is an input field component for multi-line text input.
A TestBench element representing a
<vaadin-text-area>
element.Tester for TextArea components.
Set of theme variants applicable for
vaadin-text-area component.Text Field allows the user to input and edit text.
Internal class that provides base functionality for input field components,
such as
TextField.A TestBench element representing a
<vaadin-text-field>
element.Tester for TextField components.
Set of theme variants applicable for the
TextField component, as well
as other components based on it.Map holding the data of a text node.
A renderer that renders each item as a text using provided
ItemLabelGenerator.Text style that defines how to render texts on the map.
Common logic for
VerticalLayout and HorizontalLayout related
to dynamic theme adjustment.Theme class for Chart.
Defines the theme to use for the application.
Holds all the settings needed to properly set a Theme in the application.
Handler for ThemeEditor debug window communication messages.
Custom bean serializer for
GradientColor inside ChartOptionsRepresentation of the theme names for an
Element.Default implementation for the
ThemeList that stores the theme names
of the corresponding element.Watches the given theme folder for changes, combines the theme on changes and
pushes the new version to the browser.
Helpers related to theme handling.
Theme handling methods.
Base definition for a typed theme variant enum of a component
For categorized axes only.
The position of the tick marks relative to the axis line.
Abstract base class for map sources providing tiled images from a URL
Layer for displaying tiled map data
Abstract base class for map sources providing tiled map data
Source for loading tile data from WMS (Web Map Service) servers
These settings affect how datetime axes are laid out, how tooltips are
formatted, how series pointIntervalUnit works and how the Highstock range
selector handles time.
Time Picker is an input field for entering or selecting a specific time.
invalid-changed event is sent when the invalid state changes.A TestBench element representing a
<vaadin-time-picker>
element.A TestBench element representing
<vaadin-time-picker-combo-box> element inside the
<vaadin-time-picker> element.A TestBench element representing
<vaadin-time-picker-overlay> element that contains the
items for the <vaadin-time-picker> element when the
drop down has been opened with TimePickerElement.openDropDown().Tester for TimePicker components.
Set of theme variants applicable for
vaadin-time-picker component.Class used to define allowed multiples a time unit is allowed to be grouped
to.
Serializer for
TimeUnitMultiples.The chart's main title.
Serializer for
TitleOptions for the tooltip that appears when the user hovers over a series or
point.
A handle that can be used to configure and control tooltips.
Tooltip position in relation to the target element.
A configuration class for a tooltips default behavior.
Style options for tooltips
The top of the frame around a 3D chart.
API for sending and subscribing to updates between clients collaborating on
the same collaboration topic.
A registration for configuring or removing a topic connection that is opened
with Collaboration Engine.
An action for handling a failed topic connection.
An event that is fired when the topic connection fails.
Transport modes for Push
Represents hierarchical data.
An in-memory data provider for listing components that display hierarchical
data.
Tree Grid is a component for displaying hierarchical tabular data grouped
into expandable and collapsible nodes.
Array update strategy aware class for TreeGrid.
TestBench Element API for TreeGrid.
The layout algorithm used by
ChartType.TREEMAP charts.The direction where the layout algorithm will start drawing.
A collection of
TreeSeriesItems that compose a
multi-root tree.This class represents one node in a
TreeSeries.The topmost component in any component hierarchy.
Placeholder view when navigating from server-side views to client-side
views.
Exception thrown if the UI has been detached when it should not be.
A strategy to handle redirects which is aware of UIDL requests.
Processes a UIDL request from the client.
Serializes pending server-side changes to UI state to JSON.
Provides context information for the resolve operations.
Event fired to
UIInitListener when a UI has been initialized.Event listener that can be registered for receiving an event when a
UI is initialized.Holds UI-specific methods and data which are intended for internal use by the
framework.
A
Page.executeJs(String, Serializable...) invocation that has not
yet been sent to the client.The implementation of this interface is responsible for updating the UI with
given content.
Stereotype annotation for Spring's
@Scope("vaadin-ui").A SpringLookupInitializer that adapts Spring ApplicationContext to
WebApplicationContext and registers it into ServletContext so that lookup can
be initialized correctly.
Base JUnit 4 class for UI unit tests.
Exception thrown by
BaseUIUnitTest methods when the mock environment
has not been set up correctly.A base class for generating an unique object that is serializable.
Enum of supported units in Css sizes.
Exception thrown for when a FeatureFlag that doesn't exist is checked.
Exception thrown for when a node task that is not in the task list is
encountered.
Component representing a
<ul> element.A TestBench element representing a
<ul> element.A
RequestHandler that presents an informative page that the browser
in use will not work.UnsupportedPropertyTypeException is throw when
WebComponentExporter tries to register a
property encasing an unsupported value type.Upload is a component for uploading one or more files.
A TestBench element representing a
<vaadin-upload>
element.Upload exception class.
The I18N helper file for the upload component.
Translations for adding files.
Translations for dropping files.
Exception translations.
file translations.
Abstract translation class for single and multi mode translations.
unit translations.
Upload time translation strings.
Communication error translations.
Time remaining translations.
Upload status strings.
FileOutputStream with a reference to the output file.
Tester for Upload components.
Abstract base class for map sources providing tiled map data from a URL
Internal utility class for URL handling.
Collects entries that should be exported for vaadin-usage-statistics when
running in development mode.
A usage statistics entry.
A class for exporting
UsageStatistics entries.User information of a collaborating user, used with various features of the
collaboration engine.
Marks that an annotated component implicitly uses another component.
Internal annotation to enable use of multiple
Uses annotations.Vaadin Application Spring configuration.
Represents Vaadin web application initialization bootstrap.
Servlet initializer visiting
AppShellConfigurator configuration.A strategy that uses an available VaadinSession for retrieving the security
context.
Provides configuration of Vaadin aware
SecurityContextHolderStrategyEmpty class which makes Flow add npm @vaadin/bundles dependency.
Configuration in which
VaadinService is running.Configuration properties for Vaadin Spring Boot.
Context in which
VaadinService is running.Allows to run initialization of
VaadinContext which for some reasons
may not be done via ServletContextListener.Applies this initializer to the given
VaadinContext.A default request cache implementation which aims to ignore requests that are
not for routes.
Registers runtime hints for Spring 3 native support.
Enumeration of all icons in the Vaadin
Icons collection.
Indicates an issue during Vaadin initialization.
Abstract Vaadin Spring MVC
WebApplicationInitializer.A generic request to the server, wrapping a more specific request type, e.g.
A generic response from the server, wrapping a more specific response type,
e.g.
Implementation of Spring's
Scope that binds the beans
to a component in the navigation chain.A version of
SavedRequestAwareAuthenticationSuccessHandler that
writes a different return value for a Fusion TypeScript client.Redirect strategy used by
VaadinSavedRequestAwareAuthenticationSuccessHandler.Internal registrar for Vaadin scan packages settings.
Vaadin scopes configuration.
An abstraction of the underlying technology, e.g.
Listener for
VaadinService initialization events.The main servlet, which handles all incoming requests to the application.
VaadinConfig implementation for Servlets.Vaadin servlet configuration.
VaadinContext that goes with VaadinServletService.Servlet context initializer for Spring Boot Application.
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.
Wrapper for
HttpServletRequest.Wrapper for
HttpServletResponse.A service implementation connected to a
VaadinServlet.Contains everything that Vaadin needs to store for a specific user.
Stereotype annotation for Spring's
@Scope("vaadin-session").Implementation of Spring's
Scope that binds the beans
to the current VaadinSession (as opposed to
the current Servlet session).The lifecycle state of a VaadinSession.
Contains helper methods to work with Spring Data based back-ends and Vaadin
components.
VaadinStatelessSecurityConfigurer<H extends org.springframework.security.config.annotation.web.HttpSecurityBuilder<H>>
Enables authentication that relies on JWT instead of sessions.
Implementation of Spring's
Scope that binds the beans
to the current UI.Utility for translating special Vaadin URIs into URLs usable by the browser.
Provides basic Vaadin component-based security configuration for the project.
Handles registration of JSR-356 websocket endpoints when the Spring Boot
application is run in an embedded container.
Indicates validation errors in a
Binder when a field value is
validated.Represents the result of a validation.
Simple validation result implementation.
The event to be processed when
ValidationStatusChangeListener.validationStatusChanged(ValidationStatusChangeEvent)
invoked.The listener interface for receiving
ValidationStatusChangeEvent
events.Util methods for component validation
A functional interface for validating user input or other potentially invalid
data.
All possible value change modes that can be set for any component extending
HasValueChangeMode.Value context for
Converters.A callback interface for providing values from a given source.
Layer for rendering vector data client-side
Provides information about the current version of Vaadin Flow.
Alignment of the title relative to the axis values and more generically
vertical alignment.
Vertical Layout places components top-to-bottom in a column.
A TestBench element representing a
<vaadin-horizontal-layout> element.Represents a map's viewport, responsible for changing properties like center
and zoom level
Checks access to views using an
AccessAnnotationChecker.Helper for checking access to views.
Annotation to use to scan given packages for routes and error views.
Defines a viewport tag that will be added to the HTML of the host page of a
UI class.
List of nodes describing the virtually connected child elements of an
element.
Virtual List allows you to render a long list of items inside a scrollable
container without sacrificing performance.
A TestBench element representing an
<vaadin-virtual-list>
element.Handles communication with a Vite server.
Communicates with a Vite server through a websocket connection.
The websocket endpoint for Vite.
Connects a brower-server websocket connection with a server-Vite websocket
connection.
DataSeriesItem that can be used as sum or intermediate sum in waterfall
charts.
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.
Acts as a proxy to the web component root onto which the exporter
Component is added.Represents a single instance of a exported web component instance embedded
onto a host page.
Bootstrap handler for WebComponent requests.
Result of defining an embeddable web component using
WebComponentExporter.Registry for storing available web component configuration implementations.
Servlet initializer for collecting all classes that extend
WebComponentExporter/WebComponentExporterFactory on startup,
creates unique WebComponentConfiguration instances, and adds them to
WebComponentConfigurationRegistry.Exports a
Component as a web component.Produces
WebComponentConfiguration instances from either
WebComponentExporter classes or instances.Checks that specific annotations are not configured wrong.
Exports a
Component as a web component.Default factory implementation which uses an exporter class to
instantiate it using its default constructor.
Retrieves web component tag from a
WebComponentExporterFactory object.Internal utility methods for
WebComponentExporter and
WebComponentExporterFactory classes.Generates a client-side web component from a Java class.
Writes web components generated from
WebComponentExporter implementation classes
to a target directory.Enables the usage of given
WebComponentModulesWriter class via
reflection.Request handler that supplies the script/html of the web component matching
the given tag.
Custom UI for use with WebComponents served from the server.
Event used for sending the activation event for an exported web component
from the client to the server.
Wrapper component for a web component that exposes
ClientCallable
methods that the client-side components expect to be available.Wrapper for similarly named Browser API.
This callback is notified after the value has been retrieved from the
client side.
Marks a Navigation url parameter as a wildcard allowing 0-N parameter parts
to be bound for this url parameter.
Wrapper for
HttpSession.A generic session, wrapping a more specific session implementation, e.g.
The XAxesExtremesSetEvent class stores data for set extremes events on the x
axes of the chart.
The X axis or category axis.
Source for loading tiled images from a map service using the
Slippy
Map tile numbering scheme, also known as XYZ format.
The YAxesExtremesSetEvent class stores data for set extremes events on the y
axes of the chart.
The Y axis or value axis.
The Z axis or depth axis for 3D plots.
Defines the Axis on which the zones are applied.
An array defining zones within a series.
BrowserLiveReloadAccessorinstead