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.An abstract field class that is backed by a composite component.
Defines a base contract for configuration (e.g. on an application level,
servlet level,...).
A configuration factory base logic which reads the token file.
An abstract base class for DeploymentConfiguration implementations.
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.
A base class for commands providing helpers for common file generation
actions.
Generic initializer logic.
Change describing an operation (add/remove) in a
list node
feature.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.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 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.
Abstract class for generating client files.
Abstract element state provider for text nodes.
Abstract theme definition class for defining theme variables when in use.
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.
Checks if a user has access to a given route path.
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.
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.
Checks access to views using an
AccessAnnotationChecker.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.
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.
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.
The
Attributes class represents a set of attributes.Represents a view configuration for use with a menu.
Implementation which stores data for basic elements, i.e. elements which are
not bound to any template and have no special functionality.
Implementation of
Style for BasicElementStateProvider.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.
Utility class for Java Beans information access.
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.
Mixin interface to handle blur events on components.
Represents the DOM event "blur".
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. the
initial GET request.
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.
Parses the user agent string from the browser and provides information about
the browser.
Detected operating systems.
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.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.
Bundle handling methods.
Utilities related to various case operations.
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.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.Methods which are published as
element.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 generic command interface meant to be used for passing lambdas around.
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.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.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.
Route configuration class that is used as a value object.
Configuration class for editing routes.
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.Constants used by the server side framework.
Content type resolver.
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.
Callback for handling attributes with special semantics.
Validates custom-element name according to definition in Custom
element name
Contains the system messages used to notify the user about various critical
situations that can occur.
Utilities for commercial product handling.
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.
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.
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.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.Event fired before a
Component is detached from the UI.Mixin interface for components that support adding detach listeners.
Helpers related to the development bundle.
Provides API to access to the
DevModeHandler instance by a
VaadinService.Representation of the security token exchanged with the Dev Tools client to
validate websocket connections.
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.
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.
Exception indicating a failure during file download.
Exception indicating a conflict between a route target implementing
HasDynamicTitle while also having a PageTitle annotation.Represents an element in the DOM.
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.
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.
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.Empty change for the feature to report its presence for the client (send the
feature information even though its data is empty).
Utilities related to various encoding schemes.
A factory for creating Vaadin Endpoint generator tasks.
A container for utility methods related with Hilla endpoints.
Contains the system messages used to notify the user about various critical
situations that can occur.
A simple container with the information related to an application entry
point, i.e. those classes annotated with the
Route annotation,
extending WebComponentExporter and a bunch of more internal classes.The type of an entry point (scanned for frontend dependencies).
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.
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.
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.Provides extended information about the web browser, such as screen
resolution and time zone.
A generic command which may fail.
Handles the favicon request explicitly and return 404 for it.
Information about a feature available behind a flag.
Tracks available feature flags and their status.
FeatureFlags wrapper class for storing the FeatureFlags object.
Handle file download from given url to target destination.
A container for utility methods related with Hilla file-based router.
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".
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 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.
Marks a type, method, constructor of field to be ignored by the GWT compiler.
Contains helper methods for
VaadinServlet and generally for handling
VaadinRequests.Framework internal enum for tracking the type of a request.
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.
A component to which the user can add and remove child components.
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.
Mixin interface for field components that have helper text as property and
slots for inserting components.
A component that supports label definition.
A component which the children components are ordered, so the index of each
child matters for the layout.
A component which supports a placeholder.
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.A component that supports text content.
Represents
"white-space" style values.Represents
Component which has theme attribute.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.
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.
Event created for an application heartbeat from the client.
Handles heartbeat requests.
Listener for listening to the heartbeat of the application.
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.Represents
window.history in the browser.Event fired when the history state has changed.
Handles location change events.
Entry point for application classes hot reloads.
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.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.
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.Creates or maps Element instances to fields mapped using
@Id.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.
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.Event fired when the component has received any type of input (e.g. click,
key press).
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.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.Handles navigation by redirecting the user to some location in the
application.
This is a basic default error view shown on exceptions during navigation.
Exception indicating that the application's routes have been configured
incorrectly.
Exception indicating that the custom-element name is invalid.
Exception indicating that the application's I18N localization has been
configured incorrectly.
Thrown to indicate that a
Location instance is invalid.Exception indicating that the application's 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.
ItemLabelGenerator can be used to customize the string shown to the
user for an item.Shared code for managing contents of jar files.
Defines JavaScript dependencies on a
Component class.Internal annotation to enable use of multiple
JavaScript
annotations.Processes a 'start' request type from the client to initialize server session
and UI.
Custom BootstrapContext for
JavaScriptBootstrapHandler.Handle navigation events in relation to the client side bootstrap UI.
Helpers for replicating JavaScript semantics in Java.
Annotation for defining JavaScript Module dependencies on a
Component
class.Internal annotation to enable use of multiple
JsModule
annotations.Utility for encoding objects to and from JSON.
A utility class providing constants for JSON related features.
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.
The event when a key is pressed.
A conditional event listener for
KeyboardEvents.Possible keyboard key locations.
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.
Defines a
RouterLayout as eligible for use as automatic layout for
Flow and Hilla views.Change describing an add operation in a
list node feature.Change describing a clear operation in a
list node feature.This annotation sets the priority of execution on
BeforeEnterListeners, BeforeLeaveListeners and
AfterNavigationListeners.Change describing a remove operation in a
list node feature.Defines routes to load eagerly.
Provides method for configuring the loading indicator.
Map for storing configuration for the loading indicator.
Determines a way that dependency is loaded.
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. the hostname that can also be present in URLs.
Event created when the location changes by any of the reasons defined at
NavigationTrigger.Utility class exposing reusable utility methods for location.
A
PerRequestBroadcastFilter implementation that handles
AtmospherePushConnection.PushMessages
to ensure that a message is preserved in the BroadcasterCache until
the client has received it.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.
Change describing a changed value in a map feature.
Change describing a value removed from a map.
Model map synchronization RPC handler.
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 configuration helper class to retrieve available menu entries for
application main menu.
Data class for menu item information.
Menu entry for the main menu.
Registry for getting the menu items available for the current state of the
application.
Utility class for common
MessageDigest operations.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.
The mode the application is running in.
List for model values used in data binding in templates.
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.Context information for a navigation request.
Event object with data related to navigation.
Handles navigation to a location e.g. by showing a navigation target
component in a
UI or by redirecting the user to another location.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.
Utility class for network related methods.
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.
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.
Exception for when there is no
InputStream available.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.
Methods annotated with
NotSupported are mapped to the original
webcomponent implementation, but not supported at Java level.Annotation for defining an npm package dependency on a
Component
class which includes one or more JS modules.Internal annotation to enable use of multiple
NpmPackage
annotations.A stateless singleton node owner that is used for nodes that have not yet
been attached to a state tree.
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.Marks a Navigation url parameter as optional.
Build a
NodeExecutor instance.Represents the web page open in the browser, containing the UI it is
connected to.
Callback for receiving extended client-side details.
Defines the HTML page title for a navigation target.
Generic class representing an immutable pair of values.
Parameter deserialization utility.
Define a route url parameter details.
Defines the parent layout for components in routing hierarchy.
Immutable parser data which may be stored in cache.
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.Platform contains information about system architecture and OS.
Provides information about the current version of Vaadin Platform.
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.Container class for containing left over listeners on postponed navigation.
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.
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.
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.
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.Proxy configuration used for downloads and executions.
Class for holding proxy information.
RPC handler for events triggered through
element.Configures automatic server push.
Handles Atmosphere requests and forwards them to logical methods in
PushHandler.Provides method for configuring the push channel.
Map for storing the push configuration for a UI.
Map for storing push parameters.
Represents a bidirectional ("push") connection between a single UI and its
client-side.
Factory that produces instances of
PushConnection.Shared constants used by push.
Handles incoming push connections and messages and dispatches them to the
correct
UI/ AtmospherePushConnection.The mode of bidirectional ("push") communication that is in use.
Handles requests to open a push (bidirectional) communication channel between
the client and the server.
Defines application PWA properties.
Holds the configuration from the
PWA annotation.Handles serving of PWA resources.
Implementation of icons used in PWA resources.
Place where icon belongs to (header or manifest.webmanifest).
Registry for PWA data.
Holds query parameters information.
An immutable representation of a range, marked by start and end points.
Provides methods for configuring the reconnect dialog.
Map for storing the reconnect dialog configuration for a UI.
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 registration object for removing an event listener added to a source.
Handler for producing a response to HTTP requests.
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.
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.
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.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.Route target stores the target component and parent layouts.
Utility class with methods for route handling.
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.
Options for scrollIntoView.
Alignment for scrollIntoView.
Scroll behavior for scrollIntoView.
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.Handles a client-to-server message containing serialized RPC invocations.
Exception thrown then the security key sent by the client does not match
the expected one.
Exception thrown then the client side resynchronization is required.
A data transfer object representing an RPC request sent by the client
side.
Abstract node feature that is only present on the server.
A URI resolver which resolves paths for loading through VaadinService
resource methods.
Event fired to
ServiceDestroyListener when a VaadinService is
being destroyed.Listener that gets notified when the
VaadinService to which it has
been registered is destroyed.Thrown for problems which occur in the
VaadinService layer.Event fired to
VaadinServiceInitListener when a VaadinService
is being initialized.All ServletContextListeners in Flow merged into one actual listener to be
able to control the order they are executed in.
Context listener that automatically registers Vaadin servlets.
Event fired when a Vaadin service session is no longer in use.
A listener that gets notified when a Vaadin service session is no longer
used.
Exception indicating that the session has expired.
A specialized RequestHandler which is capable of sending session expiration
messages to the user.
Event gets fired when a new Vaadin service session is initialized for a
Vaadin service.
Event listener that can be registered to a
VaadinService to get an
event when a new Vaadin service session is initialized for that service.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.
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.
Misc internal utility methods used by both the server and the client package.
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.
A pojo for Spring CSRF token.
A util class for helping dealing with Spring CSRF token.
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
"/*".Implementation of
StreamVariable.StreamingEndEvent.Implementation for
StreamVariable.StreamingErrorEvent.Implementation for
StreamVariable.StreamingProgressEvent.Implementation for
StreamVariable.StreamingStartEvent.Represents a receiver for data upload from the client.
Handles
StreamReceiver instances registered in VaadinSession.An UploadInterruptedException will be thrown by an ongoing upload if
StreamVariable.isInterrupted() returns true.Stream registration result.
Represents dynamically generated data.
Handles
StreamResource instances registered in VaadinSession.Registry for
StreamResource instances.Output stream consumer.
StreamVariable is a special kind of variable whose value is streamed to an
OutputStream provided by the StreamVariable.getOutputStream() method.Event passed to
StreamVariable.streamingFinished(StreamingEndEvent) method the
contents have been streamed to StreamVariable successfully.Event passed to
StreamVariable.streamingFailed(StreamingErrorEvent) method when
the streaming ended before the end of the input.Streaming event interface.
Event passed to
StreamVariable.onProgress(StreamingProgressEvent) method during
the streaming progresses.Event passed to
StreamVariable.streamingStarted(StreamingStartEvent) method
before the streaming of the content to StreamVariable starts.Utility class for special string handling.
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().Defines style sheet dependencies on a
Component class.Internal annotation to enable use of multiple
StyleSheet
annotations.Utility methods for
Style.A component that displays a given SVG image.
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.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.
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.
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.
A component which encapsulates the given text in a text node.
Map holding the data of a text node.
Defines the theme to use for the application.
Holds all the settings needed to properly set a Theme in the application.
Representation of the theme names for an
Element.Default implementation for the
ThemeList that stores the theme names
of the corresponding element.Helpers related to theme handling.
Theme handling methods.
Handles translation file requests.
Transport modes for Push
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.
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.
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.
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 exception class.
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.
Marks that an annotated component implicitly uses another component.
Internal annotation to enable use of multiple
Uses annotations.Represents Vaadin web application initialization bootstrap.
Servlet initializer visiting
AppShellConfigurator configuration.Configuration in which
VaadinService is running.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.Implementor ot this interface are responsible for update Vaadin components
when application classes change.
Indicates an issue during Vaadin initialization.
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.
An abstraction of the underlying technology, e.g. servlets, for handling
browser requests.
Listener for
VaadinService initialization events.The main servlet, which handles all incoming requests to the application.
VaadinConfig implementation for Servlets.VaadinContext that goes with VaadinServletService.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.
The lifecycle state of a VaadinSession.
Utility for translating special Vaadin URIs into URLs usable by the browser.
A callback interface for providing values from a given source.
Provides information about the current version of Vaadin Flow.
Deprecated, for removal: This API element is subject to removal in a future version.
for annotation based view security use
NavigationAccessControl with
AnnotatedViewAccessChecker.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.
Provides information about the web browser the user is using that is directly
available in the request, for instance browser name and version and IP
address.
Acts as a proxy to the web component root onto which the exporter
Component is added.Represents a single instance of a exported web component instance embedded
onto a host page.
Bootstrap handler for WebComponent requests.
Result of defining an embeddable web component using
WebComponentExporter.Registry for storing available web component configuration implementations.
Servlet initializer for collecting all classes that extend
WebComponentExporter/WebComponentExporterFactory on startup,
creates unique WebComponentConfiguration instances, and adds them to
WebComponentConfigurationRegistry.Exports a
Component as a web component.Produces
WebComponentConfiguration instances from either
WebComponentExporter classes or instances.Checks that specific annotations are not configured wrong.
Exports a
Component as a web component.Default factory implementation which uses an exporter class to
instantiate it using its default constructor.
Retrieves web component tag from a
WebComponentExporterFactory object.Internal utility methods for
WebComponentExporter and
WebComponentExporterFactory classes.Generates a client-side web component from a Java class.
Writes web components generated from
WebComponentExporter implementation classes
to a target directory.Enables the usage of given
WebComponentModulesWriter class via
reflection.Request handler that supplies the script/html of the web component matching
the given tag.
Custom UI for use with WebComponents served from the server.
Event used for sending the activation event for an exported web component
from the client to the server.
Wrapper component for a web component that exposes
ClientCallable
methods that the client-side components expect to be available.Wrapper for similarly named Browser API.
This callback is notified after the value has been retrieved from the
client side.
Marks a Navigation url parameter as a wildcard allowing 0-N parameter parts
to be bound for this url parameter.
Wrapper for
HttpSession.A generic session, wrapping a more specific session implementation, e.g.
BrowserLiveReloadAccessorinstead