All Classes

Internal helper for AttachEvent and DetachEvent.

Abstract base class for implementing BackEndHierarchicalDataProviders.

Abstract base class for PropertyDefinition implementations for beans.

The callback executed when the manager is activated, i.e.

An abstract field class that is backed by a composite component.

A configuration factory base logic which reads the token file.

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.

An abstract base class for DeploymentConfiguration implementations.

An abstract implementation of a field, or a Component allowing user input.

Encapsulates all the logic required for a typical field implementation.

Abstract implementation of a GridMultiSelectionModel.

Abstract hierarchical data provider implementation which takes care of item refreshes and associated events.

Abstract lazy data view implementation which handles the interaction with a data communicator.

Abstract list data view implementation which provides common methods for fetching, filtering and sorting in-memory data to all ListDataView subclasses.

`forgot-password` is fired when the user clicks Forgot password button

SPI for customizing lookup in applications inside Servlet 3.0 containers.

Abstract implementation of the ElementStateProvider related to the composition essence of the provider.

Abstract class to be used as a parent for node maps which supports setting properties in a map.

Configuration interface to use for updating the configuration entity.

Abstract invocation handler implementation with common methods.

Custom bean serializer for AbstractSeries that adds the type field.

Abstract superclass for chart series items

Abstract class for collecting Methods which are published as serverObject.<name> on the client side.

Abstract stream resource class.

Abstract class for generating client files.

Abstract element state provider for text nodes.

An abstract base class for typed validators.

Options for configuring accessibility for the chart.

Accordion is a a vertically stacked set of expandable panels.

An accordion panel which could be opened or closed.

Defines when to execute the connection callback

The base interface for every AfterNavigationEvent handler.

Any attached component implementing this interface will receive an event after all navigation tasks have resolved.

Makes a @ClientCallable method callable even if the UI is inert.

Component representing an <a> element.

Represents target attribute values for an <a> element.

Validation class that is run during servlet container initialization which checks that specific annotations are not configured wrong.

Server-side component for the <vaadin-app-layout> element.

Sections in the component that can be used as primary.

Configuration on the application level.

A utility class providing static constants.

RouteRegistry wrapper class for storing the ApplicationRouteRegistry.

Checks whether the provided class is an AppShellConfigurator eligible for the web application.

A wrapper class for storing the AppShellRegistry instance in the servlet context.

Exception indicating a failure during extraction of an archive file.

Array update strategy aware class.

Component representing a <article> element.

Defines the default assets that the Map component provides

Represents a message that can arrive as multiple fragments.

Event fired after a Component is attached to the UI.

RPC handler for a client-side response on attach existing element request.

RPC handler for a client-side response on attach existing element by id request.

The Attributes class represents a set of attributes.

Values for the autocomplete attribute.

The internationalization properties for AvatarGroup.

The internationalization properties for AvatarGroup.

Set of theme variants applicable for vaadin-avatar-group component.

Alternative AxisContainer to allow multiple axes

Event for information about rescaling the axis.

The axis title, showing next to the axis line.

Enum representing different axis types.

The interface between a cluster backend and Collaboration Engine.

A data provider that lazy loads items from a back end.

An object, or array of objects, for backgrounds.

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.

The feature contains a value of the basic type.

Contains properties for a bean type which is nested in another definition.

Delegates serialization calls to the given instance of BeanSerializationDelegate.

Binder that uses reflection based on the provided bean type to resolve bean properties.

Event created before navigation happens.

A listener that may be added to the UI using UI.addBeforeEnterListener(BeforeEnterListener).

Abstract before event class that has the common functionalities for BeforeLeaveEvent and BeforeEnterEvent.

The base interface for every BeforeLeaveEvent handler.

Any attached component implementing this interface will receive an event before leaving the current navigation state.

Validator for validating that an BigDecimal is inside a given range.

Connects one or more Field components to properties of a backing data type such as a bean type.

Creates a binding between a field and a data property.

An internal implementation of Binding.

Handler for applying effects to HasValue components in Binder based on ValidationResult for the user input.

Handler for BinderValidationStatus changes.

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).

Status of the validation.

Mixin interface to handle blur events on components.

Vaadin Board allows creating responsive layouts in an easy way.

A Vaadin internal runtime exception thrown when the writing of the bootstrap page in BootstrapHandler fails for some reason.

Provides context information for the bootstrap process.

The URI resolver used in the bootstrap process.

Helper methods for use in bootstrapping.

The callback used by bootstrap handlers in order to know when a request is a valid URL to render the page.

A DataSeriesItem implementation suitable for box plot charts.

An array defining breaks in the axis, the sections defined will be left out and all the points shifted closer to each other.

Detected operating systems.

Provides a way to reload browser tabs via web socket connection passed as a AtmosphereResource.

Default implementation for BrowserLiveReloadAccessor that stores the instance in the Vaadin context.

Listener that gets notified when the size of the browser window containing the uI has changed.

A collection of options for buttons appearing in the exporting module.

Options for the export related buttons, print and export.

Set of theme variants applicable for vaadin-button component.

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 fetching a stream of items from a backend based on a query.

Event fired when a cell in the Grid is focused.

Fired after a chart is printed using the print menu

The ChartClickEvent class stores information on click events anywhere on the area of the chart.

ChartDrillupEvent triggered after all the series has been drilled up if chart has multiple drilldown series

Interface shared by all enum classes of the vaadin charts.

Fired after a chart is loaded

The ChartOptions configures a page local global options like localized texts for charts.

Fired after a chart is redrawn

Util class that handles the configuration needed for the model classes to be serialized to JSON.

The default series type for the chart.

Server-side component for the vaadin-checkbox-group element.

Data view implementation for Checkbox Group with in-memory list data.

Callback which allows to handle request to map a client side DOM element to the server Element instance.

Interface for annotated and subclass class searches.

Implementation that searches for annotated classes or subclasses in a list of classes.

Allows to load the implementation class by one classloader but accepts classes in ClassLoaderAwareServletContainerInitializer.onStartup(Set, ServletContext) method loaded by another classloader.

Listener that receives the clicked item (or tapped item, in touch devices).

Event fired when a component is clicked.

Publishes the annotated method so it can be invoked from the client side using the notation this.$server.method().

Callback for creating a stream resource with the image for a specific user.

CollaborationEngine is an API for creating collaborative experiences in Vaadin applications.

A VaadinServiceInitListener which uses the Instantiator to find whether an instance of CollaborationEngineConfiguration is provided as a bean in the current environment, using that instance if found.

A map that is shared between multiple users.

Extension of the MessageInput component which integrates with the CollaborationMessageList.

Configurator callback for messages in a CollaborationMessageList.

A query to fetch messages from a backend.

Submitter of messages.

Renderer for columns that doesn't use any template for rendering its contents (only the value from the object model).

Event fired when a Grid column is resized by the user.

Server-side component for the vaadin-combo-box webcomponent.

Predicate to check ComboBox items against user typed strings.

Data view implementation for ComboBox with lazy data fetching.

Set of theme variants applicable for vaadin-combo-box component.

The YAxis will show percentage or absolute change depending on whether compare is set to Compare.PERCENT or Compare.VALUE

A Component is a higher level abstraction of an Element or a hierarchy of Elements.

A DataGenerator that manages the creation and passivation of components generated by ComponentRenderers.

An event bus for Components.

Generic listener for component events.

Immutable meta data related to a component class.

Synchronized properties defined for a Component class.

Utility methods for Component.

A DataGenerator that aggregates multiple DataGenerators and delegates the data generation to them.

Abstract class for composition events.

The event when a composition is started.

Under which conditions the rule applies.

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.

Contains the configuration for the map, such as layers, sources, features.

Route configuration class that is used as a value object.

Server-side component for the <vaadin-confirm-dialog> element.

`confirm` is sent when the user clicks Confirm button

The context in which a topic connection is active.

Wraps a JSON value that should be stored in the ConstantPool shared between the client and the server.

Constants used by the server side framework.

Options for the export button.

Server-side component for <vaadin-context-menu>.

Server-side component for the vaadin-cookie-consent element, used for showing a cookie consent banner the first time a user visits the application, until the banner is dismissed.

Represents map coordinates in a specific projection.

Configure a crosshair that follows either the mouse pointer or the hovered point.

A component for performing CRUD operations on a data backend (e.g entities from a database).

Event fired when the user tries to delete 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 tries to save a new item or modifications to an existing item.

Enum with the possible values for the crud's editor position.

A simple grid implementation for Crud that allows searching and sorting backed by a data provider.

The confirmation dialogs used in the component

The confirmation options on a dialog

The set of theme variants applicable to the vaadin-crud component.

Imports a CSS file into the application bundle.

Keeps track of various current instances for the current thread.

Callback for handling attributes with special semantics.

A HasValue whose UI content can be constructed by the user, enabling the creation of e.g.

Dash styles used to render lines.

An event fired when the data of a DataProvider changes.

DataProvider base class.

Wraps the component's filter object with the meta information whether this filter changing should trigger the item count change event.

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.

Options for the series data labels, appearing next to each data point.

Extended data labels for range series types.

Data change events listener.

Custom bean serializer for DataProviderSeries

Event when the data was removed.

The DataSeriesItem class represents a single entry in a DataSeries.

Custom bean serializer for DataSeriesItem

DataSeriesItem that can hold also Label and Description values.

Event for updating existing data series.

Internal utility class used by data view implementations and components to simplify the filtering and sorting handling, but not limited to it.

The internationalization properties for DatePicker.

Validator for validating that a LocalDate is inside a given range.

For a DATETIME axis, the scale will automatically adjust to the appropriate unit.

Validator for validating that a LocalDateTime is inside a given range.

Converter for handling conversion between Date and Date.

Defines phases for an event that is debounced.

BrowserLiveReload implementation class.

Default implementation of ApplicationConfigurationFactory.

Default implementation for file archive extraction.

Default implementation of BinderValidationErrorHandler.

The default implementation of DeploymentConfiguration based on a base class for resolving system properties and a set of init parameters.

The default implementation of ErrorHandler.

Default instantiator that is used if no other instantiator has been registered.

Default implementation of the RouteResolver interface.

System messages provider using the built-in default system messages.

The type of a dependency.

List for storing dependencies/files (JavaScript, Stylesheets) to be loaded and included on the client side.

A collection of properties configured at deploy time as well as a way of accessing third party properties not explicitly supported by this class.

Component representing a <dl> element.

Component representing a <dt> element.

Mixin interface for components that support adding detach listeners.

Provides API to access to the DevModeHandler instance.

Trigger for running dev mode initialization when running in a compatible servlet environment.

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.

Options for the dial or arrow pointer of the gauge.

`vaadin-dialog-close-action` is sent when the user clicks outside the overlay or presses the escape key.

Set of theme variants applicable for vaadin-dialog component.

Specifies the direction of the text and other content inside of an element.

Component representing a <div> element.

Maps a DOM event to a ComponentEvent.

Server-side listener for client-side DOM events.

Validator for validating that a Double is inside a given range.

Mixin interface that provides basic drag source API for any component.

Server-side component for the <vaadin-drawer-toggle> element.

Handler interface for chart's drilldown callbacks.

The DrilldownEvent class stores information on click events in drilldown points

What box to align the button to.

Used to specify the drop effect to use on dragenter or dragover events.

Mixin interface that provides basic drop target API for any component.

Configuration for the editor of an edit column.

Holds the data for cancel events fired in Editor.

Holds the data for close events fired in Editor.

Base class for events fired in Editor.

Holds the data for open events fired in Editor.

Renderer and DataGenerator used by Grid.Column to control the state of the editor components.

An event listener for a Grid editor save events.

Used to specify the effect that is allowed for a drag operation.

Event fired after an Element has been attached to the UI.

Map for element attribute values.

Handles CSS class names for an element.

Map of basic element information.

Listener for element detach events.

Map of DOM events with server-side listeners.

Handles storing and retrieval of the state information for an element using a state node.

Provides utility methods for Element.

A string validator for e-mail addresses.

Empty change for the feature to report its presence for the client (send the feature information even though its data is empty).

Internal annotation to enable use of multiple Encode annotations.

A simple container with the information related to an application end-point, i.e.

The scope of data in a topic.

Application errors handler.

Represents the error levels displayed on components.

Event object with data related to error navigation.

Navigation error parameter class containing thrown exception and possibly a custom message.

Handles error navigation rendering in the target UI.

Maps data from a DOM event to a ComponentEvent.

RPC handler for events.

Thrown by FallibleCommand if it's unable to complete its execution.

Options for the exporting module.

Provides extended information about the web browser, such as screen resolution and time zone.

FailedEvent event is sent when the upload is received, but the reception is interrupted for some reason.

Css data stored in fallback chunk.

Handles the favicon request explicitly and return 404 for it.

A geographic feature to be displayed on a map.

Message with feature flags sent to the debug window.

FeatureFlags wrapper class for storing the FeatureFlags object.

Class containing file information for upload.

Sent when the file selected for upload doesn't meet the constraints specified on Upload

Internal filter related utilities for data provider.

DataSeriesItem that can hold also title and text values.

A component which implements Flexbox.

Enum with the possible values for the way the extra space inside the layout is distributed among the components.

Enum with the possible values for the component alignment 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.

Represents a component that can gain and lose focus.

Represents the DOM event "focus".

Component representing a <footer> element.

A footer cell in a Grid.

Server-side component for the <vaadin-form-item> element.

Enum for describing the position of label components in a FormLayout.FormItem.

Represents the class dependency tree of the application.

Frontend dependencies scanner factory.

Helps to locate the tools in the system by their names.

A class for static methods and definitions that might be used in different locations.

Thrown when detecting the version of a tool fails.

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).

Description copied from corresponding location in WebComponent:

Description copied from corresponding location in WebComponent:

Description copied from corresponding location in WebComponent:

Description copied from corresponding location in WebComponent:

Description copied from corresponding location in WebComponent:

Description copied from corresponding location in WebComponent:

Description copied from corresponding location in WebComponent:

Description copied from corresponding location in WebComponent:

Description copied from corresponding location in WebComponent:

Class providing gradient colors

A helper base class for creating extensions for the Grid component.

Builder for DataCommunicator object.

Selection mode representing the built-in selection models in grid.

Array update strategy aware class for Grid.

Server-side component for <vaadin-context-menu> to be used with Grid.

Drag end event of Grid rows.

Drop event that occurs on the Grid or its rows.

Defines the locations within the Grid row where an element can be dropped.

Data view implementation for Grid with in-memory list data.

Multiselection model interface for Grid.

Selection model implementation for disabling selection in Grid.

Event fired when the user starts to edit an existing item.

Event fired when the user has edited an existing item.

The server-side interface that controls Grid's selection state.

Sorting information for Grid.

API that allows adding content into the sub menus of a GridContextMenu to create hierarchical menus.

Marks a type, method, constructor of field to be ignored by the GWT compiler.

Component representing a <h2> element.

Component representing a <h4> element.

Component representing a <h6> element.

Contains helper methods for VaadinServlet and generally for handling VaadinRequests.

Options for the handles for dragging the zoomed area.

Mixin interface for fields with autocapitalize attribute.

Mixin interface for fields with autocorrect attribute.

A component to which the user can add and remove child components.

A generic interface for listing components that use a data provider for showing data.

Allows to resolve navigation target title dynamically at runtime.

A generic interface for components and other user interface objects that may be enabled or disabled.

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.

Mixin interface for field components that have helper text as property and slots for inserting components.

Indicates that an event has an associated item

Represents a single item component that is used inside a HasItemComponents.

Represents a component that display a collection of items and can have additional components between the items.

Interface that defines methods for fetching items lazily from a backend.

A common interface for components that can have MenuItems with click listeners inside them.

Mixin interface for text-field components that have prefix and suffix slots for inserting components.

Any component implementing this interface supports setting the size of the component using HasSize.setWidth(String) and HasSize.setHeight(String).

A component that supports text content.

Represents Component which has theme attribute.

Utility methods to transform urls and parameters from/into the HasUrlParameter format into/from the template format.

A generic interface for field components and other user interface objects that have a user-editable value that should be validated.

An event fired when the value of a HasValue changes.

A component that has a value.

Component representing a <header> element.

A header cell in a Grid.

Handles heartbeat requests.

A specialized series for use with HeatMaps

Array updater strategy that is aware of hierarchical changes.

A hierarchical data provider that supports programmatically setting a filter that will be applied to all queries.

A common interface for fetching hierarchical data from a data source, such as an in-memory collection or a backend database.

Renders components as hierarchy column for tree grid.

An action to be performed to set the highlight state of the target.

A condition to meet to determine the highlight state of the target.

Represents window.history in the browser.

Handles location change events.

HorizontalLayout is a component container, which shows the subcomponents in the order of their addition (horizontally).

Component representing a <hr> element.

Base class for a Component that represents a single built-in HTML element.

A HTML label that can be positioned anywhere in the chart area.

Component representing a <object> element.

I18N provider interface for internationalization usage.

An icon or image that can be used to visually represent a Feature, by using it as the feature's Style.setImage(ImageStyle)

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.

Component representing a <iframe> element.

Sandbox types.

Component representing a <img> element.

Abstract base class for all sources providing a single image

Abstract base class for drawing image-based features

Source for WMS servers providing single, untiled images

Immutable class list implementation.

This class is responsible for serving the index.html according to the template provided in the frontend folder.

This represents the state of a Index HTML response being generated.

Content wrapping mode enum.

Three argument consumer.

Internal annotation to enable use of multiple Inline annotations.

File content wrapping enum.

A mixin interface for in-memory data providers.

Component representing an <input> element.

Mixin interface for components that support adding input listeners to the their root elements.

Exception indicating a failure during installation of node and npm.

A factory for an Instantiator.

Server-side component for the vaadin-integer-field element.

Handles navigation by redirecting the user to some location in the application.

Irregular time unit used to define point interval unit.

Exception indicating that the custom-element name is invalid.

Thrown to indicate that a Location instance is invalid.

Exception indicating that Route layouts configuration has problems.

Event fired when a Grid item is clicked.

Listener interface for getting updates on data item count changes.

ItemLabelGenerator can be used to customize the string shown to the user for an item.

A HTML label that can be positioned anywhere in the chart area.

Callback that is called when a new value has been entered to an editor.

Defines JavaScript dependencies on a Component class.

Processes a 'start' request type from the client to initialize server session and UI.

Custom UI for JavaScriptBootstrapHandler.

Helpers for replicating JavaScript semantics in Java.

Internal annotation to enable use of multiple JsModule annotations.

A utility class providing constants for JSON related features.

Base interface for classes that are serializable to and from JsonObject.

Utility methods to create JSON nodes.

Initializer class for JSR 356 websockets.

An interface to represent keyboard keys.

Options for keyboard navigation.

A conditional event listener for KeyboardEvents.

KeyMapper is the simple two-way map for generating textual keys for objects and retrieving the objects later with the key.

Mixin interface for components that support adding key event listeners to the their root elements.

The event when a key is released.

Component for a <label> element, which represents a caption for an item in a user interface.

Language object.

The layout of the legend items.

The legend is a box containing a symbol and name for each series item or point item in the chart.

Style options for Legend

Serializer for LegendTitle.

Event that is fired during license lifecycle, e.g.

Event handler that gets notified on license events.

Change describing an add operation in a list node feature.

Base class for the ListBox and MultiSelectListBox.

Data view implementation for ListBox with in-memory list data.

Change describing a clear operation in a list node feature.

DataView for a in-memory list data that provides information on the data and allows operations on it.

The result of an insertion in a CollaborationList.

An object which identifies each item of a CollaborationList.

Change describing a remove operation in a list node feature.

Event handler that gets notified for changes to collaboration lists.

Component which renders a LitElement template.

Lit template content parser.

Wrapper for the parsing result.

The loading options control the appearance of the loading screen that covers the plot area on chart operations.

Map for storing configuration for the loading indicator.

A simple backend implementation that only distributes events locally and assumes that there is no previous history for event logs.

A template renderer for presenting LocalDateTime objects.

A converter that converts between LocalDate and Date.

Any com.vaadin.ui.Component implementing this interface will be informed when the UI locale is changed and on attach.

Represents a relative URL made up of path segments and query parameters, but lacking e.g.

Utility class exposing reusable utility methods for location.

Internationalization object for customizing the component UI texts.

I18n properties for the form.

Server-side component for the <vaadin-login-overlay> component.

Provides a way to discover services used by Flow (SPI).

Default implementation of AppShellPredicate.

Default implementation of ResourceProvider.

Lumo component theme class implementation.

The default theme for Vaadin Charts.

Map is a component for displaying geographic maps from various sources.

Event that is fired when the value in a collaboration map changes.

Provides data for click events on geographic features

Change describing a value removed from a map.

Event handler that gets notified for changes to collaboration maps.

Set of theme variants applicable for the vaadin-map component.

In Highcharts 1.0, the appearance of all markers belonging to the hovered series.

Marker style

A predefined shape or symbol for the marker.

Material component theme class implementation.

Server-side component for the vaadin-menu-bar element.

Set of theme variants applicable for vaadin-menu-bar component.

Base class for item component used inside ContextMenus.

Common management logic for context menus and sub menus.

Functional interface that defines how to handle a message when it is added to a topic.

Server-side component for the vaadin-message-input element.

The internationalization properties for MessageInput.

Item to render as a message component inside a MessageList.

Defines a meta tag with customized name and content that will be added to the HTML of the host page of a UI class.

Serializes miscellaneous metadata to JSON.

List for model values used in data binding in templates.

Helper class to store and transfer mouse event details.

Constants for mouse buttons.

Basic receiver implementation for receiving multiple file upload and storing them as files.

Interface that must be implemented by the upload receivers to provide the Upload component an output stream to write the uploaded data.

Fired when the selection changes in a listing component that supports multiple item selection.

Server-side component for the vaadin-list-box element with multi-selection.

A template renderer to create a clickable button.

Component representing a <summary> element.

Component representing a <nav> element.

Event object with data related to navigation.

Contains the information resulted from searching a route target using a navigation url as input.

Contains all relevant information related to a valid navigation.

Handles navigation events by rendering a contained NavigationState in the target UI.

The type of user action that triggered navigation.

A collection of options for the individual nodes.

Change describing that a node has been attached.

Change describing that a node has been detached.

Base class for all node changes related to a feature.

Registry of node feature id numbers and map keys shared between server and client.

Provides access to a NodeList as a Set.

Abstract root of a state node tree.

A series containing nodes and links to nodes.

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.

Element API node visitor interface.

FailedEvent that indicates that an input stream could not be obtained.

FailedEvent that indicates that an output stream could not be obtained.

Exception indicating that something went wrong while resolving navigation routes.

Server-side component for the vaadin-notification element.

Set of theme variants applicable for vaadin-notification component.

Annotation for defining an npm package dependency on a Component class which includes one or more JS modules.

Server-side component for the vaadin-number-field element.

A DataSeriesItem implementation suitable for 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.

Options to render charts in 3 dimensions.

Defines the numbering type of the list items.

DataCommunicator implementation which disables the paging and does not allow the user to set up the page for VirtualList.

Generic class representing an immutable pair of values.

Pane Container to allow multiple Panes

Allows setting a key to switch between zooming and panning.

Component representing a <param> element for <param> element.

Defines the parent layout for components in routing hierarchy.

PartialFill configuration object to be used in PlotOptionsXrange.

A pending JavaScript result that can be sent to the client.

Exception used when a CompletableFuture returned from PendingJavaScriptResult is completed exceptionally because of a client-side error.

Platform contains information about system architecture and OS.

An array of objects defining plot bands on the Y axis.

A bubble series is a three dimensional series type where each point renders an X, Y and Z value.

The column range is a cartesian series type with higher and lower Y values along an X axis.

General plotting options for the gauge series type.

Plot options for ChartType.ORGANIZATION charts.

A polygon series can be used to draw any freeform shape in the cartesian coordinate system.

A gauge showing values using a filled arc with colors indicating the value.

Styles for PlotOptions of different plot types

The size of the point shape is determined by its value relative to its siblings values.

Options for the xrange series type.

Abstract base class for features that are represented by a single point and a single coordinate.

The PointLegendItemClickEvent class stores information on click events on the charts's legend items that correspond to a chart point.

Fired when the mouse pointer moves within the neighborhood of a point

Possible values: null, ON, BETWEEN.

The PointSelectEvent class stores data for select events on the points of the chart.

The PointUpdateEvent class stores data for update events on the points of the chart

An event that is fired whenever a client polls the server for asynchronous UI updates.

Map of PolymerTemplate events with server-side listeners.

Position configuration for the credits label.

Component representing a <pre> element.

The context of the user presence.

Indicates that a previous view instance should be-reused when reloading a location in the same browser window/tab.

Set of theme variants applicable for vaadin-progress-bar component.

ProgressUpdateEvent is sent to track progress of upload.

The exception is thrown when a property change from client is disallowed on the server side.

A listener for property change events.

For internal use only.

A property from a PropertySet.

Describes a component property that has its value stored in some form in the component's element, typically an element property or attribute.

Defines the custom property name to be bound to a field component using Binder.

Proxy configuration used for downloads and executions.

RPC handler for events triggered through element.$server or simply $server in template event handlers.

Handles Atmosphere requests and forwards them to logical methods in PushHandler.

Map for storing the push configuration for a UI.

Represents a bidirectional ("push") connection between a single UI and its client-side.

Shared constants used by push.

The mode of bidirectional ("push") communication that is in use.

Defines application PWA properties.

Handles serving of PWA resources.

Place where icon belongs to (header or manifest.webmanifest).

Holds query parameters information.

Helper classes with fluent API for constructing QuerySortOrder lists.

Implementation of generic data view for RadioButtonGroup.

Set of theme variants applicable for vaadin-radio-group component.

The range selector is a tool for selecting ranges to display within the chart.

Possible timespan values for range selector buttons

Verifies that a value is within the given range.

Interface that must be implemented by the upload receivers to provide the Upload component an output stream to write the uploaded data.

Map for storing the reconnect dialog configuration for a UI.

An util class with helpers for reflection operations.

A registration object for removing an event listener added to a source.

Contains helper methods to register events triggered by rendered templates.

This interface represents a predicate which returns true if bound field should be configured to have required indicator via HasValue.setRequiredIndicatorVisible(boolean).

The button that appears after a selection zoom, allowing the user to reset zoom.

An object used to encapsulate data used in resolving routing requests.

The class that handles writing the response data into the response.

Represents the result of an operation that might fail, such as type conversion.

Server-side node feature that keeps track of the return channels registered for a state node.

Server-side component for the <vaadin-rich-text-editor> component.

Set of theme variants applicable for vaadin-rich-text-editor component.

Defines the route alias for components that function as navigation targets in routing.

Route data for an 'alias' route.

Route configuration helper class for adding, removing and reading routes from the different registries.

This is a basic default error view shown on routing exceptions.

Immutable data representing one url parameter.

Predefined regex used with template parameters.

Allows to implement a custom navigation target path generation logic for components annotated with @Route(Route.NAMING_CONVENTION).

The router takes care of serving content when the user navigates within a site or an application.

Servlet initializer for collecting all available Routes on startup.

Implementations of this interface represent a parent for a navigation target components via the Route.layout() parameter.

Result class containing the removed and added routes for the latest configuration.

Route target stores the target component and parent layouts.

Row class to define rows used in a Board instance.

Decoder of RPC method arguments (server-side methods invoked from the client-side).

A set of rules for responsive settings.

Scroller is a component container which enables scrolling overflowing content.