All Classes

Class	Description
AbstractVerticle
Acknowledgement	Structure passed to acknowledgement handler called when a ACK or NACK frame is received.
AmazonCognitoAuth	Simplified factory to create an for Amazon Cognito.
AmqpClient	AMQP Client entry point.
AmqpConnection	Once connected to the broker or router, you get a connection.
AmqpMessage	Represents an AMQP message.
AmqpMessageBuilder	Builder to create a new AmqpMessage.
AmqpReceiver	Interface used to consume AMQP message as a stream of message.
AmqpSender	AMQP Sender interface used to send messages.
AndAuthorization	Allows to perform a logical 'and' between several authorizations
APIKeyHandler	An authentication handler that provides API Key support.
ApolloWSConnectionInitEvent	NOTE: This class has been automatically generated from the original non Mutiny-ified interface using Vert.x codegen.
ApolloWSHandler	A handler for GraphQL requests sent over Apollo's subscriptions-transport-ws transport.
ApolloWSMessage	A message received over Apollo's subscriptions-transport-ws transport.
ArrayParserFactory	This interface is used to create able to parse serialized array structures.
AsyncFile	Represents a file on the file-system which can be read from, or written to asynchronously.
AsyncFileLock	A lock on a region of an AsyncFile.
AsyncMap<K,V>	An asynchronous map.
AsyncResultUni<T>
AuthenticationHandler	Base interface for auth handlers.
AuthenticationProvider	User-facing interface for authenticating users.
Authorization	Interface representing any kind of authorization such as: Role based authorization Permission based authorization Logical authorization (AND, OR, NOT) Time based authorization (ie: allow access the last 5 days of the month, from 8am till 10am, etc.)
AuthorizationContext	The AuthorizationContext contains properties that can be used to match authorizations.
AuthorizationHandler	Base interface for authorization handlers that provide authorization support.
AuthorizationProvider	The role of an AuthorizationProvider is to return a set of Authorization.
Authorizations
AuthProvider	User-facing interface for authenticating users.
AzureADAuth	Simplified factory to create an for Azure AD.
BaseBridgeEvent	Represents an event that occurs on the event bus bridge.
BasicAuthHandler	An auth handler that provides HTTP Basic Authentication support.
Bodies	In this interface you can find all available BodyProcessorFactory to use in ValidationHandlerBuilder.
Body	Handles the HTTP proxy body.
BodyCodec<T>	A codec for encoding and decoding HTTP bodies.
BodyHandler	A handler which gathers the entire request body and sets it on the .
BodyProcessorFactory	This interface is used to build body processors.
BoxAuth	Simplified factory to create an for box.com.
BridgeEvent	Represents an event that occurs on the event bus bridge.
BridgeEvent	Represents an event that occurs on the event bus bridge.
Buffer	Most data is shuffled around inside Vert.x using buffers.
CachingWebClient	An asynchronous cache aware HTTP / HTTP/2 client called CachingWebClient.
CamelBridge	Camel Bridge facade.
CassandraClient	Eclipse Vert.x Cassandra client.
CassandraRowStream	A for consumption.
ChainAuth	Chain several authentication providers as if they were one.
ChainAuthHandler	An auth handler that chains to a sequence of handlers.
CircuitBreaker	An implementation of the circuit breaker pattern for Vert.x
CLI	Interface defining a command-line interface (in other words a command such as 'run', 'ls'...).
ClientBuilder<C>	Builder for SqlClient instances.
ClientWebSocket	Represents a client-side WebSocket initially not connected.
CliToken	A parsed token in the command line interface.
CloudFoundryAuth	Simplified factory to create an for CloudFoundry UAA.
ClusteredSessionStore	A session store which stores sessions in a distributed map so they are available across the cluster.
ColumnDescriptor
Command	A Vert.x Shell command, it can be created from any language using the CommandBuilder.command(java.lang.String) or from a Java class using io.vertx.mutiny.ext.shell.command.Command#create
Command	Auto generated API Commands to interact with REDIS.
CommandBuilder	A build for Vert.x Shell command.
CommandLine	The parser transforms a CLI (a model) into an CommandLine.
CommandProcess	The command process provides interaction with the process of the command provided by Vert.x Shell.
CommandRegistry	A registry that contains the commands known by a shell.
CommandResolver	A resolver for commands, so the shell can discover commands.
Completion	The completion object
ConfigRetriever	Defines a configuration retriever that read configuration from and tracks changes periodically.
ConnectionInitEvent
ConsulClient	A Vert.x service used to interact with Consul.
ContainerDeserializer	Interface that define methods for deserialization of array and objects
Context	The execution context of a Handler execution.
ContextAwareScheduler	Helpers for producing Vert.x Context-aware schedulers.
ContextAwareScheduler.ContextCaptureStrategy	Define how a scheduler captures a Vert.x Context.
Cookie	Represents an HTTP Cookie.
CookieSessionStore	A SessionStore that uses a Cookie to store the session data.
CorsHandler	A handler which implements server side http://www.w3.org/TR/cors/[CORS] support for Vert.x-Web.
Counter	An asynchronous counter that can be used to across the cluster to maintain a consistent count.
CSPHandler	Content Security Policy (CSP) is an added layer of security that helps to detect and mitigate certain types of attacks, including Cross Site Scripting (XSS) and data injection attacks.
CSRFHandler	This handler adds a CSRF token to requests which mutate state.
Cursor	A cursor that reads progressively rows from the database, it is useful for reading very large result sets.
CustomValidator	This interface is used to add custom synchronous functions inside validation process.
DatabaseMetadata	Contains static metadata about the backend database server
DatagramPacket	A received datagram packet (UDP) which contains the data and information about the sender of the data itself.
DatagramSocket	A datagram socket can be used to send DatagramPacket's to remote datagram servers and receive DatagramPackets .
DB2Builder	Entry point for building DB2 clients.
DB2Connection	A connection to DB2 server.
DB2Pool	A pool of DB2 connections.
DelegatingConsumerHandler<U>	A class being a Consumer and a Handler at the same time, and which delegate DelegatingConsumerHandler.hashCode() and DelegatingConsumerHandler.equals(Object) to the consumer.
DelegatingHandler<U,V>	An implementation of Handler and which delegates DelegatingHandler.hashCode() and DelegatingHandler.equals(Object) to the passed handler.
DeliveryContext<T>	Encapsulates a message being delivered by Vert.x as well as providing control over the message delivery.
Destination	Represents a STOMP destination.
DestinationFactory	Interface implemented to customize the destination creation.
DigestAuthHandler	An auth handler that provides HTTP Basic Authentication support.
DnsClient	Provides a way to asynchronously lookup information from DNS servers.
DropboxAuth	Simplified factory to create an for Dropbox.
ErrorConverter	Converts a ResponsePredicateResult to a Throwable describing the error.
ErrorHandler	A pretty error handler for rendering error pages.
EventBus	A Vert.x event-bus is a light-weight distributed messaging system which allows different parts of your application, or different applications and services to communicate with each in a loosely coupled way.
EventBusService	for event bus services (service proxies).
ExecutionInputBuilderWithContext<C>	Holds a with a contextual object.
Expectations	Helper methods to turn Vert.x Expectation that work on Future into Uni that can be used in a pipeline using the Uni.plug(Function) operator, as in:
FacebookAuth	Simplified factory to create an for Facebook.
FailurePolicy<T>	A failure policy for the CircuitBreaker.
FaviconHandler	A handler that serves favicons.
FileProps	Represents properties of a file on the file system.
FileSystem	Contains a broad set of operations for manipulating files on the file system.
FileSystemProps	Represents properties of the file system.
FileUpload	Represents a file-upload from an HTTP multipart form submission.
FormDataPart	A form data part of a MultipartForm.
FormLoginHandler	Handler that handles login from a form on a custom login page.
FoursquareAuth	Simplified factory to create an for Foursquare.
Frames	Utility methods to build common Frames.
FreeMarkerTemplateEngine	A template engine that uses the FreeMarker library.
GiteeAuth	Simplified factory to create an for Gitee.
GithubAuth	Simplified factory to create an for Github.
GitLabAuth	Simplified factory to create an for GitLab.com.
GoogleAuth	Simplified factory to create an OAuth2Auth for Google.
GraphiQLHandler	A handler for GraphiQL resources.
GraphiQLHandlerBuilder	A builder for GraphiQLHandler instances.
GraphQLHandler	A Route handler for GraphQL requests.
GraphQLHandlerBuilder	A builder for GraphQLHandler instances.
GraphQLWSHandler	A handler for the GraphQL over WebSocket Protocol.
GraphQLWSHandlerBuilder	A builder for GraphQLWSHandler instances.
HandlebarsTemplateEngine	A template engine that uses the Handlebars library.
HashingAlgorithm	Hashing Algorithm.
HashingStrategy	Hashing Strategy manager.
HashStrategy	Determines how the hashing is computed in the implementation You can implement this to provide a different hashing strategy to the default.
HealthCheckHandler	A Vert.x Web handler on which you register health check procedure.
HealthChecks	NOTE: This class has been automatically generated from the original non Mutiny-ified interface using Vert.x codegen.
HerokuAuth	Simplified factory to create an for Heroku.
HostAndPort	A combination of host and port.
HotpAuth	An extension of AuthProvider which uses the one time passwords based on counter to perform authentication.
HSTSHandler	HTTP Strict Transport Security (HSTS) RFC6797.
HtdigestAuth	An extension of AuthProvider which is using .htdigest file as store
HtpasswdAuth	An extension of AuthProvider which is using htpasswd file as store
HTTLTemplateEngine	A template engine that uses the HTTL library.
HttpClient	An asynchronous HTTP client.
HttpClientBuilder	A builder for HttpClient.
HttpClientRequest	Represents a client-side HTTP request.
HttpClientResponse	Represents a client-side HTTP response.
HttpConnection	Represents an HTTP connection.
HttpEndpoint	for HTTP endpoint (REST api).
HttpFrame	An HTTP/2 frame.
HttpHeaders	Contains a bunch of useful HTTP headers stuff: methods for creating instances often used Header names method to create optimized CharSequence which can be used as header name and value
HTTPOperationRequestValidationHandler	Base interface for HTTP request validation with API specification
HttpProxy	Handles the HTTP reverse proxy logic between the user agent and the origin.
HttpRequest<T>	A client-side HTTP request.
HTTPRequestValidationHandler	An interface for add HTTP Request validation.
HttpResponse<T>	An HTTP response.
HttpResponseHead	The state of the HTTP response head: Status code / Message Headers
HttpServer	An HTTP and WebSockets server.
HttpServerFileUpload	Represents an file upload from an HTML FORM.
HttpServerRequest	Represents a server-side HTTP request.
HttpServerResponse	Represents a server-side HTTP response.
HystrixMetricHandler	A Vert.x web handler to expose the circuit breaker to the Hystrix dasbboard.
IBMCloudAuth	Simplified factory to create an for IBM Cloud.
InfinispanSessionStore	An implementation of that relies on the Infinispan Java Client.
InputTrustHandler	Base input trust interface for handlers that verify the trust of the request.
InstagramAuth	Simplified factory to create an for Instagram.
JadeTemplateEngine	A template engine that uses Jade.
JDBCAuth	Factory interface for creating AuthenticationProvider instances that use the Vert.x JDBC client.
JDBCAuthentication	NOTE: This class has been automatically generated from the original non Mutiny-ified interface using Vert.x codegen.
JDBCAuthorization	NOTE: This class has been automatically generated from the original non Mutiny-ified interface using Vert.x codegen.
JDBCClient	An asynchronous client interface for interacting with a JDBC compliant database
JDBCDataSource	NOTE: This class has been automatically generated from the original non Mutiny-ified interface using Vert.x codegen.
JDBCHashStrategy	Determines how the hashing is computed in the implementation You can implement this to provide a different hashing strategy to the default.
JDBCPool	JDBCPool is the interface that allows using the Sql Client API with plain JDBC.
JDBCUserUtil	NOTE: This class has been automatically generated from the original non Mutiny-ified interface using Vert.x codegen.
Job	A job executed in a JobController, grouping one or several process.
JobController	The job controller.
JsonEvent	A JSON event emited by the JsonParser.
JsonFormatValidator
JsonParser	A parser class which allows to incrementally parse json elements and emit json parse events instead of parsing a json element fully.
JsonPointer	Implementation of RFC6901 Json Pointers.
JsonPointerIterator	The JsonPointerIterator is used by the read/write algorithms of the JsonPointer to read/write the querying data structure Every method takes the currentValue as parameter, representing the actual value held by the query algorithm. Implementations of this interface should be stateless, so they can be reused You can implement this interface to query the structure you want using json pointers
JsonSchema	A Json-Schema holder.
JWTAuth	Factory interface for creating JWT based AuthenticationProvider instances.
JWTAuthHandler	An auth handler that provides JWT Authentication support.
JWTAuthorization	Implementation of the JWT authorization provider.
KafkaAdminClient	Vert.x Kafka Admin client implementation
KafkaConsumer<K,V>	Vert.x Kafka consumer.
KafkaConsumerRecord<K,V>	Vert.x Kafka consumer record
KafkaConsumerRecords<K,V>	Vert.x Kafka consumer records
KafkaHeader	Vert.x Kafka producer record header.
KafkaProducer<K,V>	Vert.x Kafka producer.
KafkaProducerRecord<K,V>	Vert.x Kafka producer record.
KeycloakAuth	Simplified factory to create an for Keycloak.
KeycloakAuthorization	Implementation of the Keycloak Authorization Provider.
LanguageHeader	A parsed language header.
LdapAuthentication	Factory interface for creating a LDAP AuthenticationProvider.
LinkedInAuth	Simplified factory to create an for LinkedIn.
LiveAuth	Simplified factory to create an for live.com Services.
LocalMap<K,V>	Local maps can be used to share data safely in a single Vert.x instance.
LocalSessionStore	A session store which is only available on a single node.
Lock	An asynchronous exclusive lock which can be obtained from any node in the cluster.
LoggerFormatter	Implement to format the output of the LoggerHandler
LoggerHandler	A handler which logs request information to the Vert.x logger.
MailAttachment	Represent a mail attachment that can be used in a MailMessage.
MailchimpAuth	Simplified factory to create an for Mailchimp.
MailClient	SMTP mail client for Vert.x
Measured	NOTE: This class has been automatically generated from the original non Mutiny-ified interface using Vert.x codegen.
Message<T>	Represents a message that is received from the event bus in a handler.
Message	A GraphQL over WebSocket Protocol message.
MessageConsumer<T>	An event bus consumer object representing a stream of message to an EventBus address that can be read from.
MessageProducer<T>	Represents a stream of message that can be written to.
MessageSource	Service type for data producer.
MetaDataService	Factory interface for creating FIDO2 MetaDataService.
MethodOverrideHandler	NOTE: This class has been automatically generated from the original non Mutiny-ified interface using Vert.x codegen.
MetricsService	The metrics service mainly allows to return a snapshot of measured objects. This service is derived and adapted from MetricsService in the vertx-dropwizard-metrics module.
MicroProfileAuthorization	Implementation of the Microprofile MP-JWT 1.1 RBAC based on the access token groups key.
MIMEHeader
MongoAuth	An extension of AuthProvider which is using as store
MongoAuthentication	An extension of AuthProvider which is using as store
MongoAuthorization	An extension of AuthProvider which is using as store
MongoClient	A Vert.x service used to interact with MongoDB server instances.
MongoDataSource	NOTE: This class has been automatically generated from the original non Mutiny-ified interface using Vert.x codegen.
MongoGridFsClient
MongoUserUtil	Utility to create users/roles/permissions.
MqttClient	An MQTT client
MqttConnAckMessage	Represents an MQTT CONNACK message
MqttDisconnectMessage	Represents an MQTT CONNACK message
MqttEndpoint	Represents an MQTT endpoint for point-to-point communication with the remote MQTT client
MqttMessage	Represent the interface for each MQTT message
MqttPubAckMessage	Represents an MQTT PUBACK message
MqttPubCompMessage	Represents an MQTT PUBCOMP message
MqttPublishMessage	Represents an MQTT PUBLISH message
MqttPubRecMessage	Represents an MQTT PUBREC message
MqttPubRelMessage	Represents an MQTT PUBREL message
MqttServer	An MQTT server
MqttSubAckMessage	Represents an MQTT SUBACK message
MqttSubscribeMessage	Represents an MQTT SUBSCRIBE message
MqttTopicSubscription	Represents a subscription to a topic
MqttUnsubscribeMessage	Represents an MQTT UNSUBSCRIBE message
MSSQLBuilder	Entry point for building MSSQL clients.
MSSQLConnection	A connection to Microsoft SQL Server.
MSSQLPool	A of SQL Server connections.
MultiHelper
MultiMap	This class represents a MultiMap of String keys to a List of String values.
MultipartForm	A multipart form.
MultiReadStream<T,U>
MultiTenantHandler	A handler which selectively executes another handler if a precondition is met.
MutinyGen	Associate an Mutiny generated class with its original type,used for mapping the generated classes to their original type.
MutinyHelper
MVELTemplateEngine	A template engine that uses the Handlebars library.
MxRecord	Represent a Mail-Exchange-Record (MX) which was resolved for a domain.
MySQLBuilder	Entry point for building MySQL clients.
MySQLClient	An interface to define MySQL specific constants or behaviors.
MySQLConnection	An interface which represents a connection to MySQL server.
MySQLPool	A of MySQL Connections.
NetClient	A TCP client.
NetServer	Represents a TCP server
NetSocket	Represents a socket-like interface to a TCP connection on either the client or the server side.
NotAuthorization	Allows to perform a logical 'not' of the specified authorization
OAuth2Auth	Factory interface for creating OAuth2 based AuthenticationProvider instances.
OAuth2AuthHandler	An auth handler that provides OAuth2 Authentication support.
OAuth2WebClient	An asynchronous OAuth2/OIDC aware HTTP / HTTP/2 client called WebClientOAuth2.
ObjectParserFactory	This interface is used to create able to parse serialized object structures.
OpenAPI3RequestValidationHandler	NOTE: This class has been automatically generated from the original non Mutiny-ified interface using Vert.x codegen.
OpenAPI3RouterFactory	Interface for OpenAPI3RouterFactory.
OpenAPIHolder
OpenIDConnectAuth	Simplified factory to create an OAuth2Auth for OpenID Connect.
Operation	Interface representing an Operation
OracleBuilder	Entry point for building Oracle clients.
OracleClient	An interface to define Oracle specific constants or behaviors.
OracleConnection	A connection to Oracle Database.
OraclePool	Represents a pool of connection to interact with an Oracle database.
OrAuthorization	Allows to perform a logical 'or' between several authorizations
OtpAuthHandler	An auth handler that provides One Time Password (Multi-Factor) Authentication support.
OtpKeyGenerator	Otp key generator.
ParameterProcessorFactory	This interface is used to build parameter processors supported on every .
Parameters	In this interface you can find all available ParameterProcessorFactory to use in ValidationHandlerBuilder.
ParameterTypeValidator	Interface for declaration of method for validate a specific parameter type. If you want to implement your own type validator, you need only to implement ParameterTypeValidator.isValid(java.lang.String): If parameter is valid, call to put value (maybe modified) inside RequestParameters.
ParameterValidationRule	This function is an inner wrapper for ParameterTypeValidator inside ValidationHandler parameter maps.
ParsedHeaderValue
ParsedHeaderValues	A container with the request's headers that are meaningful enough to be parsed Contains: Accept -> MIME header, parameters and sortable Accept-Charset -> Parameters and sortable Accept-Encoding -> Parameters and sortable Accept-Language -> Parameters and sortable Content-Type -> MIME header and parameters
Parsers	In this interface you can find all available ArrayParserFactory, ObjectParserFactory & TupleParserFactory
PebbleTemplateEngine	A template engine that uses the Pebble library.
PermissionBasedAuthorization	Represents a permission Note that the permission can optionally be assigned to a specific resource
PgBuilder	Entry point for building PostgreSQL clients.
PgChannel	A channel to Postgres that tracks the subscription to a given Postgres channel using the LISTEN/UNLISTEN commands.
PgConnection	A connection to Postgres.
PgPool	A of PostgreSQL connections.
PgSubscriber	A class for managing subscriptions using LISTEN/UNLISTEN to Postgres channels.
Pipe<T>	Pipe data from a ReadStream to a WriteStream and performs flow control where necessary to prevent the write stream buffer from getting overfull.
PlatformHandler	Base platform interface for handlers that provide functionality to the application platform.
Pool	A connection pool which reuses a number of SQL connections.
PreparedQuery<T>	A query for a prepared statement allowing parameterized execution of the query, this query will use a prepared statement.
PreparedStatement	A prepared statement, the statement is pre-compiled and it's more efficient to execute the statement for multiple times.
Process	A process managed by the shell.
PrometheusScrapingHandler	A Vert.x Web Route handler for Prometheus metrics scraping.
Promise<T>	Represents the writable side of an action that may, or may not, have occurred yet.
PropertyFileAuthentication	Factory interface for creating property file based AuthenticationProvider instances.
PropertyFileAuthorization	Factory interface for creating property file based AuthenticationProvider instances.
PropertyKind<T>	The kind of the property, this can be used to fetch some specific property of the execution result.
ProtocolUpgradeHandler	Base interface for handlers that perform protocol upgrades.
ProxyContext	A controller for proxy interception.
ProxyHandler	NOTE: This class has been automatically generated from the original non Mutiny-ified interface using Vert.x codegen.
ProxyInterceptor	A HttpProxy interceptor.
ProxyRequest	Handles the interoperability of the request between the user agent and the origin.
ProxyResponse	Handles the interoperability of the response between the origin and the user agent.
Pty	A pseudo terminal used for controlling a Tty.
PugTemplateEngine	A template engine that uses Pug.
Pump	Pumps data from a ReadStream to a WriteStream and performs flow control where necessary to prevent the write stream buffer from getting overfull.
Query<T>	A query.
RabbitMQClient	NOTE: This class has been automatically generated from the original non Mutiny-ified interface using Vert.x codegen.
RabbitMQConsumer	A stream of messages from a rabbitmq queue.
RabbitMQMessage	Represent a message received message received in a rabbitmq-queue.
RabbitMQPublisher	A reliable publisher that Queues up messages internally until it can successfully call basicPublish.
ReadStream<T>	Represents a stream of items that can be read from.
ReadStreamSubscriber<R,J>
RecordParser	A helper class which allows you to easily parse protocols which are delimited by a sequence of bytes, or fixed size records.
RedirectAuthHandler	An auth handler that's used to handle auth by redirecting user to a custom login page.
Redis	A simple Redis client.
RedisAPI	Auto generated Redis API client wrapper.
RedisConnection	A simple Redis client.
RedisDataSource	Service type for Redis data source.
RedisSessionStore	A SessionStore that uses a Redis to store the sessions and associated data.
Ref	JsonObject $ref resolver.
Request	Builder for REDIS requests that will be encoded according to the RESP protocol was introduced in Redis 1.2.
RequestBody
RequestParameter	Request parameter holder
RequestParameter	Request parameter holder
RequestParameters	Container for request parameters
RequestParameters	Container for request parameters
RequestPredicate	Request predicate
RequestPredicateResult	Result of a RequestPredicate
Response	The response received from the REDIS server.
ResponseContentTypeHandler	A handler which sets the response content type automatically according to the best Accept header match.
ResponsePredicate	A predicate on .
ResponsePredicateResult	Represents the outcome of a ResponsePredicate applied to an .
ResponseTimeHandler	Handler which adds a header `x-response-time` in the response of matching requests containing the time taken in ms to process the request.
ResultSet	It is like AsyncResultSet, but adapted for Vert.x.
RetryPolicy	A policy for retry execution.
RockerTemplateEngine	A template engine that uses the Rocker library.
RoleBasedAuthorization	Represents a role.
Route	A route is a holder for a set of criteria which determine whether an HTTP request or failure should be routed to a handler.
Router	A router receives request from an HttpServer and routes it to the first matching Route that it contains.
RouterBuilder	Interface to build a Vert.x Web from an OpenAPI 3 contract.
RouterFactory	Main interface for Design Driven Router factory Author: Francesco Guardiani @slinkydeveloper
RouteToEBServiceHandler	Handler that proxy the request to an event bus endpoint, waits for the reply and then writes the HTTP response.
RoutingContext	Represents the context for the handling of a request in Vert.x-Web.
Row	A single row of the execution result rowset.
RowIterator<R>	An iterator for processing rows.
RowMapper<T>	Map a to an arbitrary T object.
RowSet<R>	The execution result of the row set of a query provided as , commonly used as a RowSet.
RowStream<T>	A row oriented stream.
SalesforceAuth	Simplified factory to create an for Salesforce.
Schema	Interface representing a Json Schema
SchemaParser	Parse a Json Schema.
SchemaRepository	A repository is a holder of dereferenced schemas, it can be used to create validator instances for a specific schema.
SchemaRouter	Represents a pool where parsed schemas are addressed and cached.
ScopeAuthorization	Scope is a mechanism in OAuth 2.0 to limit an application's access to a user's account.
SecurityPolicyHandler	Base security policy interface for handlers that provide HTTP security related headers.
SecurityScheme	An authentication handler factory.
SelfSignedCertificate	A self-signed certificate helper for testing and development purposes.
ServerFrame	Structure passed to server handler when receiving a frame.
ServerWebSocket	Represents a server side WebSocket.
ServerWebSocketHandshake	A server WebSocket handshake, allows to control acceptance or rejection of a WebSocket.
ServiceDiscovery	Service Discovery main entry point.
ServiceExporter	The service exporter allows integrate other discovery technologies with the Vert.x service discovery.
ServiceImporter	The service importer allows integrate other discovery technologies with the Vert.x service discovery.
ServicePublisher	The publisher is used by the importer to publish or unpublish records.
ServiceReference	Once a consumer has chosen a service, it builds a ServiceReference managing the binding with the chosen service provider.
Session	A shell session.
Session	Represents a browser session.
SessionHandler	A handler that maintains a Session for each browser session.
SessionStore	A session store is used to store sessions for an Vert.x-Web web app
SharedData	Shared data allows you to share data safely between different parts of your application in a safe way.
Shell	An interactive session between a consumer and a shell.
ShellServer	The shell server.
ShellService	The shell service, provides a remotely accessible shell available via Telnet or SSH according to the ShellServiceOptions configuration.
ShiroAuth	Factory interface for creating Apache Shiro based AuthenticationProvider instances.
ShopifyAuth	Simplified factory to create an for Shopify.
SignalHandler	NOTE: This class has been automatically generated from the original non Mutiny-ified interface using Vert.x codegen.
SimpleAuthenticationHandler	A user customizable authentication handler.
SocketAddress	The address of a socket, an inet socket address or a domain socket address.
SockJSHandler	A handler that allows you to handle SockJS connections from clients.
SockJSSocket	You interact with SockJS clients through instances of SockJS socket.
SockJSTermHandler	NOTE: This class has been automatically generated from the original non Mutiny-ified interface using Vert.x codegen.
SoundcloudAuth	Simplified factory to create an for SoundCloud.
SqlAuthentication	Factory interface for creating AuthenticationProvider instances that use the Vert.x SQL client.
SqlAuthorization	Factory interface for creating instances that use the Vert.x SQL client.
SqlClient	Defines common SQL client operations with a database server.
SQLClient	A common asynchronous client interface for interacting with SQL compliant database
SqlClientHelper	Utilities for generating Multi and Uni with a SqlClient.
SqlConnection	A connection to the database server.
SQLConnection	Represents a connection to a SQL database
SQLOperations	Represents a SQL query interface to a database
SqlOutParam	Tag if a parameter is of type OUT or INOUT.
SqlResult<T>	An interface that represents the execution result of an operation on the database server.
SQLRowStream	A ReadStream of Rows from the underlying RDBMS.
SqlTemplate<I,R>	An SQL template.
SqlUserUtil	Utility to create users/roles/permissions.
SrvRecord	Represent a Service-Record (SRV) which was resolved for a domain.
StaticHandler	A handler for serving static resources from the file system or classpath.
StompClient	Defines a STOMP client.
StompClientConnection	Once a connection to the STOMP server has been made, client receives a StompClientConnection, that let send and receive STOMP frames.
StompServer	Defines a STOMP server.
StompServerConnection	Class representing a connection between a STOMP client a the server.
StompServerHandler	STOMP server handler implements the behavior of the STOMP server when a specific event occurs.
StreamBase	Base interface for a stream.
StripeAuth	Simplified factory to create an for Stripe.
StyledParameterProcessorFactory	This interface is used to build complex parameter processors supported only in cookie & query.
TcpEventBusBridge	TCP EventBus bridge for Vert.x
TemplateEngine	A template template uses a specific template and the data in a routing context to render a resource into a buffer.
TemplateHandler	A handler which renders responses using a template engine and where the template name is selected from the URI path.
Term	The terminal.
TermServer	A server for terminal based applications.
ThymeleafTemplateEngine	A template engine that uses the Thymeleaf library.
TimeoutHandler	Handler that will timeout requests if the response has not been written after a certain time.
TimeoutStream	A timeout stream is triggered by a timer, the Handler will be call when the timer is fired, it can be once or several times depending on the nature of the timer related to this stream.
Timer	A timer task that can be used as a future.
TotpAuth	An extension of AuthProvider which uses the one time passwords based on time to perform authentication.
Transaction	A transaction.
Tty	Provide interactions with the Shell TTY.
Tuple	A general purpose tuple.
TupleMapper<T>	Map an arbitrary T object to a .
TupleParserFactory	This interface is used to create able to parse serialized object structures.
TwitterAuth	Simplified factory to create an for Twitter.
TypeArg<T>
UniHelper
UploadScalar
UriTemplate	A URI template that follows the rfc6570 level 4.
User	Represents an authenticates User and contains operations to authorise the user.
ValidationHandler	Base interface for validation.
ValidationHandler	This is the entry point of this module.
ValidationHandlerBuilder	Builder for a .
Validator	A validator, validates some input object using a well known schema.
Variables	Holds a set of name/value pairs where each value can be a String or a List or a Map.
Vertx	The entry point into the Vert.x Core API.
VertxBatchLoader<K,V>	A that works well with Vert.x callback and based APIs.
VertxBuilder	A builder for creating Vert.x instances, allowing to configure Vert.x plugins: metrics tracing cluster manager Example usage:
VertxContextPRNG	A secure non blocking random number generator isolated to the current context.
VertxContextPRNG	A secure non blocking random number generator isolated to the current context.
VertxDataFetcher<T>	A that works well with Vert.x callback and based APIs.
VertxMappedBatchLoader<K,V>	A that works well with Vert.x callback and based APIs.
VertxParameterProvider
VertxPropertyDataFetcher	Extends so that properties can be read from a .
Watch<T>	Watches are a way of specifying a view of data (e.g. list of nodes, KV pairs, health checks) which is monitored for updates.
WatchResult<T>
WebAuthn	Factory interface for creating WebAuthN based AuthenticationProvider instances.
WebAuthnHandler	An auth handler that provides FIDO2 WebAuthN Relay Party support.
WebClient	An asynchronous HTTP / HTTP/2 client called WebClient.
WebClientSession	An asynchronous sessions aware HTTP / HTTP/2 client called WebClientSession.
WebEnvironment	Utility API to verify which environment is the web application running.
WebSocket	Represents a client-side WebSocket.
WebSocketBase	Base WebSocket implementation.
WebSocketClient	An asynchronous WebSocket client.
WebSocketFrame	A WebSocket frame that represents either text or binary data.
WildcardPermissionBasedAuthorization	Represents a wildcard permission (ie: 'manage:order:*' '*:orders', '*', etc.)
WorkerExecutor	An executor for executing blocking code in Vert.x .
WriteStream<T>	Represents a stream of data that can be written to.
WriteStreamSubscriber<T>	A WriteStream to Flow.Subscriber adapter.
XFrameHandler	The X-Frame-Options HTTP response header can be used to indicate whether or not a browser should be allowed to render a page in a , , or