We use cookies to serve our customers and website visitors in the best possible way. Cookies are used for the proper functioning of the website and for improving the user experience, monitoring visitor traffic and marketing purposes. By continuing to browse the site, you agree to our use of cookies. You can read more about cookies here.
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.
Base class for tests using WebDriver.
A superclass with helper methods to aid TestBench developers create a JUnit 5 based tests.
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.
A base class for commands providing helpers for common file generation actions.
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.
The internationalization properties for AbstractNumberField.
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.
This is abstract error view for routing exceptions.
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.
Decision on navigation access.
Indicates a class that is responsible for taking a decisions about granting
access to a target view, based on the result provided by
NavigationAccessCheckers.
A representation of the access check result, potentially providing deny reason.
Annotation for customizing route specific rerouting of access denied error in
AnnotatedViewAccessChecker.
Exception for access denied error view.
Options for configuring accessibility for the chart.
Checks if a user has access to a given route path.
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.
A filter that requires all children to pass.
Checks access to views using an AccessAnnotationChecker.
Container for labels on the chart
Label that can be positioned anywhere in the chart area
Contains coordinates for AnnotationItemLabel
Helper 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 AppLayout
Sections 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 Halo
The Attributes class represents a set of attributes.
The authentication context of the application.
Helpers for authentication related tasks.
Helpers for authentication related tasks.
Capitalization options for the autocapitalize attribute.
Values for the autocomplete attribute.
Represents a view configuration for use with a menu.
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 AxisList
Event 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.
The internationalization properties for BigDecimalField.
A TestBench element representing a
<vaadin-big-decimal-field> element.
Validator for validating that an BigDecimal is inside a given range.
A converter that converts from BigDecimal to Double and back.
A converter that converts from BigDecimal to Float and back.
A converter that converts from BigDecimal to Integer and
back.
A converter that converts from BigDecimal to Long and back.
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.
Makes the methods of the annotated class available to the browser.
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.
TestBench Extension that provides WebDriver configuration and
startup according to given test configuration and desired capabilities.
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.
Shorthand annotation for marking test methods in test class.
A superclass with helper methods to aid TestBench developers create a JUnit 5 based tests.
Shorthand annotation for enabling
@ExtendWith(MultipleBrowsersExtension.class) on test class.
Record that is automatically resolved by BrowserExtension providing
most important information on currently run test.
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 DrillUpButton
Options 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.
A configuration object to configure style of connectors (dependencies) between two points in a Gantt 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 ChartEnum
Fired 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.
Modifier that adds special handling for ChartOptions and
GradientColor inside ChartOptions
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.
The internationalization properties for Checkbox.
A TestBench element representing a <vaadin-checkbox>
element.
CheckBoxGroup is a multi-selection component where items are displayed as check boxes.
The internationalization properties for CheckboxGroup.
CheckboxGroup.ItemHelperGenerator can be used to generate helper text strings
used by the checkbox group for each checkbox.
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.
Event fired when the user toggles the selection state of an item on the client-side.
Deprecated, for removal: This API element is subject to removal in a future version.
Provider is deprecated, use
FrontendUtils.getClientRoutes() instead.Client route target stores the target template.
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 applies callbacks to the service
instance to reinitialize the state of topic connection context after
de-serialization.
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.
The internationalization properties for ComboBox.
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
ComboBox
Event 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
Callback interface for counting the number of items in a backend based on a Spring Data Pageable and a filter string.
Callback interface for fetching a list of items from a backend based on a Spring Data Pageable and a filter string.
The internationalization properties for ComboBoxBase.
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.
Thrown by CommandRunner when a command is not available.
A generic command runner which throws a CommandRunnerException.
A generic exception thrown by a CommandRunner.
The YAxis will show percentage or absolute change depending on
whether compare is set to Compare.PERCENT or Compare.VALUE
Progress indicator, how much of the task completed
A 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.
Exception for when there is a problem with compressing files.
Utility class for compression and decompression of folders and files.
Under which conditions the rule applies.
A condition for registering components only when a given feature flag is enabled.
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.
A configuration object to configure style of connectors (dependencies) between two points in a Gantt chart.
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.
A browser-callable service that can count the given type of objects with a given filter.
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.
CrudRepositoryService<T,ID,R extends org.springframework.data.repository.CrudRepository<T,ID> & org.springframework.data.jpa.repository.JpaSpecificationExecutor<T>>
A browser-callable service that delegates crud operations to a JPA repository.
A browser-callable service that can create, read, update, and delete a given type of object.
The set of theme variants applicable to the vaadin-crud component.
Handles checking of a CSRF token in endpoint requests.
An index HTML request listener that generates and sends a token for Cross-Site Request Forgery protection (Double Submit Cookie pattern) of endpoints.
A listener that creates and registers a CsrfIndexHtmlRequestListener.
Utility methods to handle application theme CSS content.
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.
Dashboard is a responsive layout component that allows users to organize widgets either directly within the dashboard or optionally group them into sections.
The internationalization properties for Dashboard.
Fired when an item was moved.
Fired when an item enters or exits move mode.
Fired when an item was removed.
Fired when a widget was resized.
Fired when an item enters or exits resize mode.
Fired when an item was selected.
DashboardSection is a container for organizing multiple
DashboardWidget instances within a Dashboard.
DashboardWidget represents a customizable widget that can be placed within a
Dashboard.
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 DataProviderSeries
Wrapper 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 DataSeriesItem
DataSeriesItem that can hold also target and targetOptions.
DataSeriesItem that can hold also "from", "to" and "weight".
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.
The internationalization properties for DateTimePicker.
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.
Interface to be implemented to customize Daily Active Users feature.
A DauEnforcementException is thrown when License Server imposes enforcement for the application and the EnforcementRule check is not satisfied.
A utility class for various daily active users collecting methods.
Record to hold the DAU enforcement check result with the messages and the action to be run at the end of the request.
A helper to mark operations that might be eligible for DAU tracking
Request interceptor that collects daily active users and stores them in the in-memory cache.
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 AccessCheckDecisionResolver that allow
access only if input results are all ALLOW, or a combination of ALLOW and
NEUTRAL.
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 TestBenchBrowserFactory used to generate
DesiredCapabilities through BrowserFactory
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 i18n provider that will be initialized if custom I18NProvider
is not available.
Factory for DefaultI18NProvider.
Default instantiator that is used if no other instantiator has been registered.
Default implementation of MenuAccessControl.
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.
A fake DevModeHandler whose only purpose is to eagerly show a "build in progress" HTML page to the user, during the creation of the development bundle.
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.
Representation of the security token exchanged with the Dev Tools client to validate websocket connections.
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.
`dragged` event is sent when the user finishes dragging the overlay.
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.
An internal controller for handling disabling a component when it is clicked.
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.
A converter that converts from Double to BigDecimal and back.
Exception indicating a failure during file download.
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 DrillUpButton
Class implementing this interface can provide own WebDriver to be
used during test execution.
Used 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.
Class for holding name, comparison, and value for matching attributes.
Attribute matching comparisons.
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.
The internationalization properties for EmailField.
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.
Annotation to mark the endpoints to be processed by
EndpointController class.
Component used for checking role-based ACL in Vaadin Endpoints.
Handles (re)generation of the TypeScript code.
The controller that is responsible for processing Vaadin endpoint requests.
A configuration class for customizing the EndpointController class.
An exception that is intended to be thrown by any Vaadin endpoint method to propagate exception details to the client side.
Annotation marks the class itself should not be treated as an
Endpoint, but inheritable methods will be added to the descendant
Endpoints.
A factory for creating Vaadin Endpoint generator tasks.
Exception thrown by EndpointInvoker when invocation fails.
Exception indicating access to the endpoint was denied.
Exception indicating a problem with the request data.
Exception indicating an unexpected server error occured during handling of the endpoint invocation.
Exception indicating the endpoint was not found.
Handles invocation of endpoint methods after checking the user has proper access.
A checker responsible for validating the Vaadin endpoint names.
Class that contains all Vaadin endpoint customizable properties.
Keeps track of registered endpoints.
Tracks methods inside a given endpoint class.
A container for utility methods related with Hilla endpoints.
A subscription that wraps a Flux and allows to listen for unsubscribe events from the browser.
Defines mappings for certain endpoint types to corresponding transfer types.
A mapper for endpoint values that is capable of converting between the given endpoint and transfer type.
A deserializer for MultipartFile.
A util class related to classes available to the browser.
A validation exception class that is intended to be thrown when any endpoint method receives invalid parameter(s).
A validation error data.
Contains the system messages used to notify the user about various critical situations that can occur.
Functional interface for finding browser-callable classes.
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.
Utility class for use with ErrorHandler to show HasErrorParameter view when an exception happens during a RPC call outside of navigation.
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.
Excludes dependencies listed in an "exclusions" array of vaadin-*versions.json file from a package.json.
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.
An exception which is thrown when somebody attempts to use Dashboard
or DashboardWidget components without activating the associated
feature flag first.
A checker for TypeScript null compatibility in Vaadin endpoint methods parameter and return types.
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 event
Checks if a given feature flag, defined using
ConditionalOnFeatureFlag, is enabled.
Message 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.
Represents an HTML <fieldset> element.
Represents an HTML <legend> element.
Basic in file receiver implementation.
Class containing file information for upload.
Handle file download from given url to target destination.
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 Upload
Sent when a file selected for upload is removed.
A container for utility methods related with Hilla file-based router.
Watches for the file or sub-directory changes in the given directory.
Superclass for all filters to be used with CRUD services.
A PathMatchingResourcePatternResolver that allows filtering resources
by package properties.
Utility class for transforming property names in filters and pageable objects.
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.
A converter that converts from Float to BigDecimal and back.
A utility class for various daily active users collecting methods.
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.
A browser-callable service that can create, update, and delete a given type of object.
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, bun) 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).
A series of tasks to be used in the Gantt chart.
Data for the GanttSeries.
A configuration object to express dependencies between tasks in a Gantt chart.
A helper for tasks to handle generated files.
Collect generated-flow-imports content for project to use to determine if dev-bundle contains all required imports.
A browser-callable service that can fetch the given type of object.
Global options that don't apply to each chart.
Class providing gradient colors
Runs a Gradle command.
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 chain
Selection mode representing the built-in selection models in grid.
Callback interface for counting the number of items in a backend based on a Spring Data Pageable.
Callback interface for fetching a list of items from a backend based on a Spring Data Pageable.
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.
Style options for the guide box.
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.
Deprecated.
Since 24.6, this interface is no longer supported.
Deprecated.
Since 24.6, this event is no longer supported.
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 WebDriver
Allows 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.
Implemented by elements which support a label via its text, such as buttons.
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.
A component which supports a placeholder.
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.
HasWidgets is an interface for components that can contain and manage
multiple DashboardWidget instances.
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.
Registers runtime hints for Spring 3 native support for Hilla.
Reports Hilla statistics.
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.
Entry point for application classes hot reloads.
Takes care of updating internals of Hilla that need updates when application classes are updated.
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.
Utility class for use with determining default i18n property files and locales.
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.
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.
The internationalization properties for IntegerField.
A TestBench element representing a <vaadin-integer-field>
element.
Validator for validating that an Integer is inside a given range.
A converter that converts from Integer to BigDecimal and
back.
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.
An exception thrown when the event type is null or 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 Menu access control has been configured incorrectly.
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.
A callback interface that is used to provide the index of an item.
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.
Utility for encoding objects to and from JSON.
Helpers for using jackson.
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.
Utility class for converting Hilla Filter specifications into JPA
filter specifications.
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.
An exception thrown when the given JSON value cannot be decoded into a value of the given Java type.
An exception thrown when the given Java value cannot be encoded into JSON.
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
Defines a RouterLayout as eligible for use as automatic layout for
Flow and Hilla views.
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.
Deprecated, for removal: This API element is subject to removal in a future version.
license events will not be received by any listener
Deprecated, for removal: This API element is subject to removal in a future version.
license events will not be received by any listener
Deprecated, for removal: This API element is subject to removal in a future version.
any implementation of this interface won't receive any events,
prefer using the default
CollaborationEngineConfiguration
constructorDeprecated, for removal: This API element is subject to removal in a future version.
license storage is not needed since 6.3
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.
ListRepositoryService<T,ID,R extends org.springframework.data.repository.CrudRepository<T,ID> & org.springframework.data.jpa.repository.JpaSpecificationExecutor<T>>
A browser-callable service that delegates list operations to a JPA repository.
A series consisting of a list of numerical values.
A browser-callable service that can list the given type of object.
Possible types of state events.
The field names used in the JSON representation of the state event.
Possible types of state events.
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.
Utility methods for unit testing properties and functions of LitRenderers.
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.
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> element
Tester 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> element
Tester 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.
A converter that converts from Long to BigDecimal and back.
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.
Set of classes for aligning items along a flexbox?s cross axis or a grid?s block axis that will be applied only for certain viewport sizes.
Classes for aligning items along a flexbox?s cross axis or a grid?s block axis that will be applied when the viewport has a minimum width of 1024px.
Classes for aligning items along a flexbox?s cross axis or a grid?s block axis that will be applied when the viewport has a minimum width of 768px.
Classes for aligning items along a flexbox?s cross axis or a grid?s block axis that will be applied when the viewport has a minimum width of 640px.
Classes for aligning items along a flexbox?s cross axis or a grid?s block axis that will be applied when the viewport has a minimum width of 1280px.
Classes for aligning items along a flexbox?s cross axis or a grid?s block axis that will be applied when the viewport has a minimum width of 1536px.
Classes for overriding individual items' align-item property.
Classes for setting the aspect ratio of an element.
Classes for setting the backdrop blur of an element.
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 defining the display property of an element that will be applied only 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 borders between elements.
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 defining 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.
Set of classes defining negative margins for an element.
Classes for setting a negative bottom margin for an element.
Classes for setting a negative logical inline end margin for an element.
Classes for setting negative left and right margins for an element.
Classes for setting a negative left margin for an element.
Classes for setting a negative right margin for an element.
Classes for setting a negative logical inline start margin for an element.
Classes for setting a negative top margin for an element.
Classes for setting negative top and bottom margins for 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 the bottom position of an element.
Set of classes defining the position of an element that will be applied only for certain viewport sizes.
Classes for defining the position of an element that will be applied when the viewport has a minimum width of 1024px.
Classes for defining the position of an element that will be applied when the viewport has a minimum width of 768px.
Classes for defining the position of an element that will be applied when the viewport has a minimum width of 640px.
Classes for defining the position of an element that will be applied when the viewport has a minimum width of 1280px.
Classes for defining the position of an element that will be applied when the viewport has a minimum width of 1536px.
Classes for setting the end position of an element.
Classes for setting a negative position for an element.
Classes for setting a negative bottom position for an element.
Classes for setting a negative end position for an element.
Classes for setting a negative start position for an element.
Classes for setting a negative top position for an element.
Classes for setting the start position of an element.
Classes for setting the top 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 transitioning various properties.
Classes for setting how the white space inside an element is handled.
Classes for setting the width of an element.
Classes for setting the z-index 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
ObjectMapper
Event 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
Deprecated.
Since 24.7, the Material theme is deprecated and will be removed
in Vaadin 25.
Runs a Maven command.
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.
Defines menu information for a route for automatically populated menu.
Interface for controlling access to routes in the application's menu component.
Enum for controlling how the client-side menu should be populated.
Menu Bar is a horizontal button bar with hierarchical drop-down menus.
The internationalization properties for MenuBar
A TestBench element representing a <vaadin-menu-bar>
element.
Tester for MenuBar components.
Set of theme variants applicable for vaadin-menu-bar component.
Menu configuration helper class to retrieve available menu entries for application main menu.
Data class for menu item information.
Menu entry for the main menu.
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.
Registry for getting the menu items available for the current state of the application.
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.
An exception thrown when a required field is missing in the JSON representation of a state event.
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.
Provides support for running test methods using multiple browsers.
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.
Defines possible behavior of the component when not all selected items can be displayed as chips within the current field width.
A TestBench element representing a
<vaadin-multi-select-combo-box> element.
Class for localization of the MultiSelectComboBox
Set 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 <table> element.
Component representing a <tbody> element.
A TestBench element representing a <tbody> element.
Represents the table caption element (<caption>).
A TestBench element representing a <caption> element.
Component representing a <td> element.
A TestBench element representing a <td> element.
A TestBench element representing a <table> element.
Component representing a <tfoot> element.
A TestBench element representing a <tfoot> element.
Component representing a <thead> element.
Component representing a <th> element.
A TestBench element representing a <th> element.
A TestBench element representing a <thead> element.
Component representing a <tr> element.
A TestBench element representing a <tr> element.
Component representing a <nav> element.
A collection of options for buttons and menus appearing in the exporting module.
Checks if a user is allowed to navigate to a specific view.
A BeforeEnterListener implementation that contains logic to perform
access checks before entering a view.
Allows to configure the NavigationAccessControl.
Helper to register navigation access control.
Context information for a navigation request.
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.
Deprecated, for removal: This API element is subject to removal in a future version.
use the standardized
NonNull
insteadFailedEvent 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.
Deprecated, for removal: This API element is subject to removal in a future version.
use the standardized
Nullable
insteadA 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.
The internationalization properties for NumberField.
A TestBench element representing a <vaadin-number-field>
element.
Tester for NumberField components.
A renderer for presenting number values.
A signal that holds a number value.
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.
Utilities for interacting with the generated openapi.json.
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.
A filter that requires at least one of its children to pass.
Map source for loading tiled images from an OpenStreetMap service.
An internal controller for automatically adding a component to the UI when it's opened.
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.
A mapper between Pageable and Pageable.
DataCommunicator implementation which disables the paging and does not allow the user to set up the page for VirtualList.
A mapper between Page and List.
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 PaneList
Allows setting a key to switch between zooming and panning.
Component representing a <p> element.
A TestBench element representing a <p> element.
Custom configuration strategy using TestBench
Parameters.getTestsInParallel().
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.
Define a route url parameter details.
Shorthand annotation for marking parameterized test methods in test class.
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.
The internationalization properties for PasswordField.
A TestBench element representing a <vaadin-password-field>
element.
Pathfinder algorithm to use for chart that can connect two points (e.g.
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.
Options for the gantt series type.
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.
Plot options for ChartType.SANKEY charts.
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.
Fired while dragging a point.
Fired when starting to drag a point.
Fired when the point is dropped.
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.Popover is a component for creating overlays that are positioned next to specified component (target).
opened-changed event is sent when the overlay opened state
changes.
A TestBench element representing a <vaadin-popover>
element.
Popover position in relation to the target element.
Set of theme variants applicable for the Popover component.
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.
Helpers related to the production bundle.
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.
Helper methods for extracting and updating project statistics data.
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.
A filter that matches a given property, or nested property path, against a filter value using the specified matcher.
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.
Defines the beans needed for push in Hilla.
Represents a bidirectional ("push") connection between a single UI and its client-side.
Factory that produces instances of PushConnection.
Shared constants used by push.
Sets up and configures the push channel.
Handles incoming push connections and messages and dispatches them to the
correct UI/ AtmospherePushConnection.
Handles incoming requests from the client and connects them to fluxes returned from endpoints.
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.
The internationalization properties for RadioButtonGroup.
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.
Creates a new input element with type "range".
The orientation of the range slider.
A TestBench element representing an <input type='range'>
element.
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.
An abstract implementation of an adapter for integrating with React components.
Component used to create a React Outlet element for binding a Hilla
React view inside a Flow view.
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.
Clears all mappings from all reflection caches and related resources when one or more classes has been changed.
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.
This is a default error view shown on access denied routing exceptions.
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.
Checks if a user has access to a given route path.
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.
A component that reacts on class changes to update route registries.
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.
Tester for RouterLink components.
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.
Index HTML request listener for collecting the client side and the server side views and adding them to index.html response.
Service init listener to add the
RouteUnifyingIndexHtmlRequestListener to the service.
Utility class with methods for route handling.
A container for utility methods related with Routes.
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.
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 extension grabs a screenshot when a test fails.
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.
Proxy for the accessing the SignalRegistry.
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.
The internationalization properties for Select.
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.
Abstract class that handles selection when DataProvider.refreshAll() is
called.
Represents selection preservation mode.
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.
Animation of Gantt series connector
A configuration object to override Pathfinder connector options for a series.
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 when the client side re-sends the same request.
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.
Available strategies for session lock checking.
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
Uses RemoteDriver or LocalDriver to provide remote or local
WebDriver to run tests on.
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 TestBench element representing a <vaadin-side-nav>
element.
A menu item for the SideNav component.
A TestBench element representing a <vaadin-side-nav-item>
element.
Spring beans configuration for signals.
Handler Endpoint for Fullstack Signals' subscription and update events.
A registry for signal instances and their client signal id mappings.
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 SolidColor
Describes sorting direction.
Event describing a change in sorting of a DataProvider.
The interface for adding and removing listeners for SortEvents.
A mapper between Sort and
Sort.
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.
A Spring specific route path access checker that delegates the check to Spring Security.
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.
A Spring specific menu access control that falls back to Spring mechanisms for view access checking, when the generic mechanisms do not work.
A Spring specific navigation access control that falls back to Spring mechanisms for user retrieval and role checking, when the generic mechanisms do not work.
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.
Base JUnit 5 class for UI unit testing applications based on Spring Framework.
Helpers related to Spring.
Spring application context aware Vaadin servlet service implementation.
Deprecated, for removal: This API element is subject to removal in a future version.
No replacement planned
Deprecated, for removal: This API element is subject to removal in a future version.
ViewAccessChecker has been replaced by
NavigationAccessControl.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.
A utility class for representing state events out of an ObjectNode.
Possible types of state events.
The field names used in the JSON representation of the state event.
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.
Handles StreamResource and StreamReceiver instances
registered in VaadinSession.
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.
Decodes a JsonValue with JsonType.STRING type to Enum
subclass type.
Decodes a JsonValue with JsonType.STRING type to
Number subclass type.
Utility class for special string handling.
Style options for CSS styling
Defines how to visually represent a Feature
Provides inline styles for Elements.
Css values for the align-items property.
Css values for the align-self property.
Css values for the clear property.
Css values for the flex-basis property.
Css values for the justify-content property.
Css values for the flex-wrap property.
Css values for the float property.
Css values for the font-weight property.
Css values for the justify-content 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.
ResponseWriter is optionally returned by request handlers which implement
SynchronizedRequestHandler.synchronizedHandleRequest(VaadinSession, VaadinRequest, VaadinResponse, String)
The ResponseWriter will be executed by
SynchronizedRequestHandler.handleRequest(VaadinSession, VaadinRequest, VaadinResponse)
without holding Vaadin session lock.
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.
Tester for TabSheet component.
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.
Generates necessary PWA icons.
Generate default files for react-router if missing from the frontend folder.
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.
Deletes old files from frontend generated folder.
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.
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.
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.
The internationalization properties for TextArea.
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.
The internationalization properties for TextField.
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.
Custom bean serializer for GradientColor inside ChartOptions
Representation 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.
The internationalization properties for TimePicker.
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 Title
Options 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.
Handles translation file requests.
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.
JUnit5 extension that will collect and output the component tree for the failing test UI.
A collection of TreeSeriesItems that compose a
multi-root tree.
This class represents one node in a TreeSeries.
Implemented by classes that want to modify the bootstrap typescript.
The topmost component in any component hierarchy.
Event fired by the client to request a refresh of the user interface, by re-navigating to the current route.
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.
Base JUnit 5 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.
A context for UserIdentitySupplier configurable function.
Provides a custom identifier of end-users that, if configured, is used the by Vaadin's license server to count unique daily users for a given subscription.
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 SecurityContextHolderStrategy
Empty 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.
Implementor ot this interface are responsible for update Vaadin components when application classes change.
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.
Used to provide an around-like aspect option around request processing.
A generic response from the server, wrapping a more specific response type, e.g.
Holds role prefix accessible outside an active request.
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.
An internal controller for managing the validation state of a component.
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
Exception indicating a failure during downloaded archive verification.
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
Deprecated, for removal: This API element is subject to removal in a future version.
for annotation based view security use
NavigationAccessControl with
AnnotatedViewAccessChecker.Deprecated, for removal: This API element is subject to removal in a future version.
ViewAccessChecker has been replaced by
NavigationAccessControl.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.
Tester for VirtualList components.
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.
Matches request for custom PWA icons and Favicon paths.
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