All Classes and Interfaces

Class
Description
Deprecated, for removal: This API element is subject to removal in a future version.
An abstract element.
An abstract implementation that builds AnnotationMetadata.
The caching entry.
Base class for types that also write AnnotationMetadata.
An abstract AnnotatedArgumentBinder implementation.
An abstract implementation of the BeanConfiguration method.
Abstract implementation of the BeanConstructor interface.
Abstract constructor implementation for bean definitions to implement to create constructors at build time.
Abstract implementation of the BeanElementBuilder interface that should be implemented by downstream language specific implementations.
Abstract bean introspection reference used by BeanIntrospector to soft load introspections.
Abstract implementation of the BeanMethod interface.
Abstract implementation of BeanProperty.
Default implementation of the BeanResolutionContext interface.
A segment that represents annotation.
A segment that represents a method argument.
A segment that represents a constructor.
A segment that represents a field.
A segment that represents a method argument.
A segment that represents a method.
Abstract class that writes generated classes to disk and provides convenience methods for building classes.
Abstract implementation of the ClassWriterOutputVisitor interface that deals with service descriptors in a common way across Java and Groovy.
Base class for SslConfiguration extensions for SSL clients.
Base class for the composite customizers for the client and server.
Abstract class representing a cloud computing instance metadata.
Abstract implementation of the custom scope interface that simplifies defining new scopes using the Map interface.
Mutable annotation metadata provider.
Abstract element annotation metadata factory.
An abstract event for events specific to server applications.
Variation of AnnotationMetadata that is environment specific.
Default implementation for evaluated expressions.
Subclass of AbstractBeanMethod that also implements ExecutableMethod.
Abstract base class for generated ExecutableMethod classes to implement.
Abstract base class for ExecutableMethodsDefinition.
Internal class representing method's metadata.
An abstract executor implementation.
A class that executes the configured LocalFunctionRegistry.FUNCTION_NAME for the given inputs and outputs.
Abstract Groovy element.
A base health indicator class to extend from that catches exceptions thrown from the AbstractHealthIndicator.getHealthInformation() method and updates the HealthResult with the exception information.
Abstract class implementation of HttpClientFactory.
Abstract implementation of the HttpContentProcessor interface that deals with limiting file upload sizes.
Default implementation of the BeanDefinition interface.
The data class containing annotation injection information.
The data class containing all filed reference information.
The shared data class between method and field reference.
The data class containing all method reference information.
 
An uninitialized and unloaded component definition with basic information available regarding its requirements.
Abstract implementation of the BeanIntrospection interface.
Bean method compile-time data container.
Bean property compile-time data container.
An abstract class for other elements to extend from.
Provides an abstract class which implements LocaleResolver and handles default locale resolution.
Abstract class which implements LocalizedMessageSource and leverages LocaleResolver API.
Abstract MessageSource implementation that provides basic message interpolation.
Abstract expression AST node for method calls.
Mutable annotation metadata provider.
Abstract implementation of HttpRequest for Netty.
Abstract implementation that handles WebSocket frames.
An abstract implementation of the PropertySourceLoader interface.
Abstract bean definition for other providers to extend from.
An abstract implementation of Resource.
 
Base class for ServerSslBuilder implementations.
 
An Access log instance.
The access log format parser.
Annotate a class (typically a Java Bean) to make it explicit the style of its accessors when not using the standard getter and setters:
A contract that allows for responding to messages.
An environment that is active for the current execution of the application.
An Adapter is advice applicable to a method that will create an entirely new bean definition that delegates to the annotated method.
Internal attributes for the adapter annotation.
Expression node for binary '+' operator.
A marker interface for all BeanDefinitionReference and BeanDefinition instances to implement that provides access to the target bean type for an AOP advice bean.
The annotation processed used to execute type element visitors.
A repeatable annotation that allows defining multiple AliasFor definitions.
Allows specifying an annotation member alias.
Expression AST node for binary && operator.
A transformer that remaps androidx.annotation.Nullable to javax.annotation.Nullable.
An ArgumentBinder whose lookup is driven by an annotation definition.
An interface for classes that bind an Argument to an MutableHttpRequest driven by an annotation.
A binder that binds to a MutableHttpRequest.
An annotated element is some point in the code, whether it be a constructor, field, method etc.
Abstract validator for AnnotatedElement that may represent source code level validation routes executed at compilation time.
An ExecutableMethodProcessor for the Filter annotation.
Process methods for FunctionBean instances.
Responsible for building Route instances for the annotations found in the io.micronaut.http.annotation package.
An interface for classes that bind an Argument from an HttpRequest driven by an annotation.
An interface that provides an abstraction for checking for the existence of annotations.
An annotation class value is a reference to a class in annotation metadata.
Registers annotation converters.
Represents an annotation in the AST.
A meta annotation used to extend EvaluatedExpression context with specified type.
An AnnotationMapper is a type that is capable of mapping a given annotation to one or many annotations at compile time.
An interface implemented at compile time by Micronaut that allows the inspection of annotation metadata and stereotypes (meta-annotations)
An interface that can be implemented by other classes that delegate the resolution of the AnnotationMetadata to the AnnotationMetadataProvider.getAnnotationMetadata() method.
An exception that occurs constructing AnnotationMetadata.
Used to represent an annotation metadata hierarchy.
An interface for a type that provides AnnotationMetadata.
A reference to AnnotationMetadata.
An interface for types capable of resolving AnnotationMetadata.
Support method for AnnotationMetadata.
Responsible for writing class files that are instances of AnnotationMetadata.
An implementation of ClassWriterOutputVisitor for annotation processing.
An annotation processor is an object that processes the presence if a given annotation.
Allows remapping of annotations from one annotation set to another at compilation time.
Interface for classes that scan for classes with a given annotation.
A source of annotations.
An AnnotationTransformer transforms an annotation definition into one or many other annotation definitions discarding the original annotation.
Internal utility methods for annotations.
Utility methods for annotations.
A runtime representation of the annotation and its values.
A build for annotation values.
An interface that allows obtaining an underlying annotation value.
Interface for types that resolve annotation values.
PathMatcher implementation for Ant-style path patterns.
Qualifier that can be used on a bean to indicate it should match any qualifier or on an injection point to indicate it should match any bean.
A qualifier to lookup any type.
A class that generates AOP proxy classes at compile time.
Common application configuration.
Configuration for instance settings.
An application context extends a BeanContext and adds the concepts of configuration, environments and runtimes.
An interface for building an application context.
An interface for configuring an application context.
An application context configurer is responsible for configuring an application context before the application/function is started.
An interface for classes that manage the ApplicationContext life cycle and shut it down when the class is shutdown.
An interface for classes that provide an ApplicationContext.
An ApplicationEvent is a user specified event object.
An interface for receivers of application events.
Interface for classes that publish events received by ApplicationEventListener instances.
Constructs instances of ApplicationEventPublisher.
Event fired when an EmbeddedApplication shuts down.
Event fired when an EmbeddedApplication starts up.
Thrown when the application fails to start.
Represents an argument to a method or constructor or type.
Represents an Argument as a BeanType.
An interface capable of binding the value of an Argument from a source
The result of binding.
A registry of ArgumentBinder instances.
An interface for types that can be represented as an Argument.
Extended version of the ConversionContext specifically for conversion Argument instances.
An injection point for a method or constructor argument.
Utility methods for checking method argument values.
Allows producing error messages.
Functional interface the check a condition.
An Argument with a value.
Annotation stereotype to applied to other annotations to indicate the annotation provides Around advice.
When using Around.proxyTarget() on a Factory method if the returned bean features constructor arguments this can lead to undefined behaviour since it is expected with factory methods that the developer is responsible for constructing the object.
Allows intercepting the bean constructor.
Interface for class elements that can be converted to/from an array type.
Utility methods for working with arrays.
Utility class used to perform assertions.
The AST bean properties utils.
Internal holder class for getters and setters.
An annotation that can be applied to any method that returns void or an instance of CompletionStage to indicate the actual execution should occur on the given thread pool.
Interceptor implementation for the Async annotation.
A Publisher that uses an ExecutorService to emit a single result.
A TypeElementVisitor that validates methods annotated with @ËšAsync return void or futures.
An interface for objects that have attributes.
A base class for classes that automatically register the server with discovery services.
Print a banner programmatically.
Base class for processing ServerFilter and ClientFilter beans.
 
Interface that signals to FilterRunner that we should wait for the request body to arrive before running this binder.
A class representing basic auth authorization header.
Responsible for binding to a BasicAuth argument from the authorization header in the request.
Annotation used to configure a bean.
Extended version of ClassWriterOutputVisitor for types that write beans.
A BeanConfiguration is a grouping of several BeanDefinition instances.
Writes configuration classes for configuration packages using ASM.
Models a bean constructor.
Represents the current bean constructor when used through the BeanElementBuilder API.
The core BeanContext abstraction which allows for dependency injection of classes annotated with Inject.
Expression AST node used for to retrieve beans from bean context.
Interface for other types that are conditional within a context.
Interface for components configurable by the bean context.
Configuration for the BeanContext.
A BeanContextEvent is an event fired from the BeanContext instance.
An exception that occurs loading the context.
An event fired when a bean is created and fully initialized.
An event listener that is triggered each time a bean is created.
Context object passed to CustomScope instances for creating new beans.
A base class for exceptions that occurred during bean creation.
Defines a bean definition and its requirements.
Interface for components aware of bean definition associated with them.
Builder that produces multiple Bean definitions represented by BeanDefinitionVisitor.
Bean definition builder factory.
Returns data for a given bean definition to be used for the BeansEndpoint.
Used to respond with bean information used for the BeansEndpoint.
The core annotation processor used to generate bean definitions and power AOP for Micronaut.
An interface for a ExecutableMethod that is associated with a BeanDefinitionReference.
A bean definition processor is a processor that is called once for each bean annotated with the given annotation type.
A bean definition reference provides a reference to a BeanDefinition thus allowing for soft loading of bean definitions without loading the actual types.
Writes the bean definition class file to disk.
Core bean definition registry interface containing methods to find BeanDefinition instances.
Interface to integrate bean validation into the construction of beans within the BeanContext.
Interface for BeanDefinitionVisitor implementations such as BeanDefinitionWriter.
Responsible for building BeanDefinition instances at compile time.
Data used when visiting method.
An event fired when a bean has been destroyed and all PreDestroy methods have been invoked.
An event listener that is triggered after a bean is destroyed.
Exception type for exceptions that happen during bean destruction.
Models a bean that will be produced by Micronaut.
Interface for defining beans at compilation time from an originating element.
Allows visiting a bean to perform any validation prior to when bean definitions are written out.
Internal interface for adding associated beans.
An abstract bean event.
An exception handler capable of receiving a bean that originated the exception and an exception type.
Represents a configurable bean field.
An identifier for a Bean that can be used as a key to uniquely identify an instance.
Interface that allows extension of Bean import handling in other to support other injection systems beyond JSR-330 in downstream modules.
Implementation of Import.
Top level interface for obtaining bean information.
Allows hooking into bean instantiation at the point prior to when PostConstruct initialization hooks have been called and in the case of bean BeanProvider instances the BeanProvider.get() method has not yet been invoked.
An event fired when a bean's properties have been populated but initialization hooks (such as PostConstruct methods) have not yet been triggered.
Thrown when no such beans exists.
A BeanIntrospection is the result of compile time computation of a beans properties and annotation metadata.
A builder style API for creating instances that abstracts whether the instance is a record, bean or created by another builder.
A Jackson module that adds reflection-free bean serialization and deserialization for Micronaut.
A reference to a BeanIntrospection that may or may not be present on the classpath.
An implementation of AnnotationScanner that scans available BeanIntrospection instances through the BeanIntrospector API.
Primary interface for obtaining BeanIntrospection instances that are computed at compilation time.
Core interface for locating and discovering Bean instances.
Simple class that provides a map interface over a bean.
Represents a method on a BeanIntrospection.
Represents a configurable bean method.
Represents a configurable bean parameter.
An event fired when a bean is about to be destroyed but before any PreDestroy methods are invoked..
An event listener that is triggered before a bean is destroyed.
Bean properties configuration annotation.
The access type for bean properties.
Visibility policy for bean properties and fields.
Represents a bean property and associated annotation metadata.
An interface that provides the ability to bind Maps and Java bean properties
A BeanProvider is a richer replacement for the Provider interface that provides additional Micronaut specific methods to assist in programmatic bean creation and discovery.
Implementation for BeanProvider bean lookups.
A bean registration is an association between a BeanDefinition and a created bean, typically a Singleton.
Represents the resolution context for a current resolve of a given bean.
Represents a path taken to resolve a bean definitions dependencies.
A segment in a path.
Exposes an Endpoint to provide information about the beans of the application.
A reference to a bean.
Wraps a bean allowing to read and write its properties via an underlying BeanIntrospection.
Abstract expression AST node for binary operators.
An annotation stereotype for other annotations that indicates a method Argument is bindable.
A marker annotation for methods that are blocking.
A blocking HTTP client interface that features a subset of the operations provided by HttpClient and is designed primarily for testing purposes.
An annotation that can be applied to method argument to indicate that the method argument is bound from the HTTP body.
A binder that binds from a parsed request body.
 
HTTP Response's body assertions.
The interface for typed BodyAssertion Builders.
BodyAssertion Builder.
Byte Array BodyAssertion Builder.
String BodyAssertion Builder.
 
Expression AST node for boolean literal.
An annotation indicating that a bean can be loaded into the Bootstrap Context.
Allows blocking resolving of PropertySource from remote distributed configuration servers.
A bound Executable is an executable who argument values have been pre-bound to values using a ArgumentBinderRegistry.
An InfoSource that retrieves info from build properties.
Base class for a raw HttpBody with just bytes.
Interface for the Netty bytebuf allocator configuration.
Delegates all functionality to the provided buffer.
Interface to allow interfacing with different byte buffer implementations, primarily as an abstraction over Netty.
An allocator for ByteBuffer instances.
Handler for netty ByteBuf.
Builder for BytesSentElement.
A "cached environment" is a performance optimization aimed at minimizing the cost of calling System.getenv() or System.getProperties().
A callable injection point is an injection point that accepts Argument instances.
A MutableHttpHeaders implementation that is case-insensitive.
The Netty implementation of SslBuilder that generates an SslContext to create a server handle with SSL support via user configuration.
Creates channel options.
Factory interface for building ChannelOutboundHandler instances.
Interface that allows customizations to the ChannelPipeline.
Deprecated.
Use NettyClientCustomizer or NettyServerCustomizer instead.
Body writer for CharSequences.
Variant of MessageBodyReader that allows piecewise reading of the input, e.g.
Variation of Retryable that implements the Circuit Breaker pattern.
An event fired when a Circuit is CircuitState.CLOSED and has resumed accepting requests.
An event fired when the Circuit is CircuitState.OPEN and requests are no longer being accepted.
Runtime exception that wraps a non-runtime exception in the case of an error.
State for Circuit breaker phases.
Represents a circular dependency failure.
Stores data about an element that references a class.
Thrown when an exception occurs during compilation due to a class generation error.
A component that accepts a ClassWriterOutputVisitor and writes classes to it.
An optimized classpath scanner that includes the ability to optionally scan JAR files.
Abstraction to load resources from the classpath.
Utility methods for loading classes.
Optimizations for computing missing types.
This class has a method parameter with unresolved class.
Interface to be consumed by class writers allowing visiting file names and returning appropriate streams.
Allows defining declarative HTTP clients and customizing injection for injecting HttpClient implementations.
A binder that binds to a MutableHttpRequest.
An enum describing the type of client authentication.
A contract for providing a context path to a client.
Mark a bean as a filter for the HTTP client.
 
The client filter resolution context.
A binder that binds to a MutableHttpRequest.
 
 
 
A class that exposes information about the URI to ClientArgumentRequestBinder instances.
 
 
 
A client filter that propagates the request context.
Interface used by the netty HTTP client to construct the SSL context.
The default SslConfiguration used for HTTP clients.
Validates that disallowed types are not used in declarative client methods.
A base configuration class for configuring Client versioning.
Annotation declared on the client to indicate the class handles web socket frames.
Intercepts unimplemented ClientWebSocket methods.
Enumeration of close events.
A Qualifier that qualifies beans by generic type arguments and only returns the candidates that most closely match.
A PropertySourceLoader that reads from the environment variable VCAP_APPLICATION which is used by CloudFoundry.
A PropertySourceLoader that reads from the environment variable VCAP_SERVICES which is used by CloudFoundry.
Configuration for MediaTypeCodec instances.
An exception thrown when an object cannot be decoded.
Utility methods for working with Collection types
Represents the parsed command line options.
A build for constructing a command line parser.
A PropertySource for properties parsed from the command line.
Expression AST node for relational operations (>, <, >=, <=) on types that implement Comparable interface.
Interface that exposes a callback to indicate when an operation has been completed.
The completable future execution flow.
Represents a completed part of a multipart request.
Represents a completed part of a multipart request.
A Subscriber that tracks completion state using a AtomicBoolean.
Iterate the cookieDecoders and return the first one that returns cookies.
A composite implementation combining all registered DiscoveryClient instances.
Primary HttpLocaleResolver which evaluates every HttpLocaleResolver by order to resolve a Locale.
Composite message source that is the primary message source.
This parser is used to split complex expression into multiple single expressions if necessary and delegate each atomic expression parsing to separate instance of SingleEvaluatedEvaluatedExpressionParser, then combining single expressions parsing results.
An interface modelling common Cloud platform compute instance metadata.
Interface for resoling compute instance metadata.
Utility class for ComputeInstanceMetadataResolver's.
 
A hash table supporting full concurrency of retrievals, adjustable expected concurrency for updates, and a maximum capacity to bound the map by.
A builder that creates ConcurrentLinkedHashMap instances.
A condition allows conditional loading of a BeanConfiguration.
The ConditionContext passed to a Condition.
Abstract class for common configuration discovery settings.
The format the configuration is stored in.
Element that supports adding qualifiers.
Expression evaluation context that can be configured before evaluation.
The configurable RouteBuilder.UriNamingStrategy if property "micronaut.server.context-path" has been set.
A configuration is a grouping of bean definitions under a package.
Internal annotation that allows the definition on ConfigurationProperties on interfaces.
An annotation applicable to a field or method of a ConfigurationProperties instance that allows to customize the behaviour of properties that are builders themselves.
A Configuration client is responsible for reading configuration for configuration servers.
Implementation of DefaultVersionProvider which uses configuration.
An exception that occurs during configuration setup.
An InfoSource that retrieves values under the info key from configuration sources.
Allows injecting configuration values into a constructor or method based on the parameter names.
Internal introduction advice used to allow ConfigurationProperties on interfaces.
Metadata about a configuration group.
A builder for producing metadata for the available ConfigurationProperties.
Handles Configuration metadata generation.
An interface for classes that write ConfigurationProperties metadata.
Models a configuration path such as those declared within ConfigurationProperties and EachProperty declarations.
A segment of configuration.
 
Defines a singleton bean whose property values are resolved from a PropertyResolver.
A meta annotation for use with other annotations to indicate that the annotation reads configuration.
The visitor adds Validated annotation if one of the parameters is a constraint or @Valid.
An util class to calculate configuration paths.
Exception thrown when the client or server unexpectedly closes the connection.
Connection manager for DefaultHttpClient.
Handle for a pooled connection.
ConstantElement LogElement.
An optimization class which is used to register property sources statically.
Element for constructors.
A constructor injection point.
A ConstructorInterceptor extends the default Interceptor interface and allows intercepting constructors.
Implementation of InvocationContext for constructor interception.
An InvocationContext for construction invocation.
An annotation to indicate the MediaTypes consumed by a particular component.
A Bean Qualifier that qualifies based on the value of the media type defined in the Consumes annotation.
 
 
Exception thrown when the content length exceeds the allowed amount.
Default handle for ContentLengthExceededException errors.
Context scope indicates that the classes life cycle is bound to that of the BeanContext and it should be initialized and shutdown during startup and shutdown of the underlying BeanContext.
Annotation used to indicate the annotated class participates in the application context building phase.
This visitor is responsible for generating service files for classes annotated with ContextConfigurer.
A converter registry for converters required by the context.
Expression AST node used for context element access.
MessageBodyHandlerRegistry implementation that does not need an application context.
Expression node used for invocation of method from expression evaluation context.
Utility class to work with context paths and URIs.
 
Indicates that the role of a class is a controller within an application.
 
A conversion context is a context object supplied to a TypeConverter that allows more accurate conversion.
An interface for reporting conversion errors.
An exception thrown in the case of a ConversionError.
Handles exception of type ConversionErrorException.
A service for allowing conversion from one type to another.
Interface used when the component requires to set up bean context's ConversionService.
Interface for a component to provide the access to its ConversionService.
Specialization of ConvertibleValues where each name has multiple possible values.
An implementation of ConvertibleMultiValues that uses a backing LinkedHashMap.
Serializer for ConvertibleMultiValues.
An interface for classes that represent a map-like structure of values that can be converted.
An implementation of ConvertibleValues backed by a map.
Serializer for ConvertibleValues.
An interface representing a Cookie.
An AnnotatedArgumentBinder implementation that uses the CookieValue annotation to trigger binding from an HTTP Cookie.
An interface representing the configuration of a Cookie.
Interface to allow cookie decoding.
Builder for CookieElement and CookiesElement.
A CookieFactory creates Cookie instances and should be implemented by a concrete server.
Resolves the Locale from a Cookie within an HTTP Request.
Models the defined Cookie instances in an application.
 
An annotation that can be applied to method argument to indicate that the method argument is bound from an HTTP cookie.
Thread-safe map that is optimized for reads.
A transformer that remaps NonNull to AnnotationUtil.NON_NULL.
A transformer that remaps Nullable to AnnotationUtil.NULLABLE.
Coroutines helper.
CORS assertion.
CORS Assertion Builder.
 
Responsible for handling CORS requests and responses.
Stores configuration for CORS.
Responsible for converting a map of configuration to an instance of CorsOriginConfiguration.
 
Utility class to do CORS related assertions.
Represents a bean that has been created from a BeanCreationContext.
An annotation applicable to a constructor that provides a hint as to which constructor is the primary constructor.
This provides cron support for Java 8 using java-time.
Support CORs configuration via annotation.
 
Utility classes to work with CrossOrigin.
Strategy interface for retrieving and updating the current HealthStatus of the application.
 
This annotation is designed for non-standard http methods, that you can provide by specifying the required CustomHttpMethod.method() property.
MessageBodyHandler that is customizable with JsonFeatures.
A type that needs special handling that may include modification of the response.
Represents a custom scope within the BeanContext.
An interface for a registry of CustomScope instances.
Builder for DateTimeElement.
Default implementation of AnnotationMetadata.
Creates a default implementation of the ApplicationContext interface.
Implementation of ApplicationContextBuilder.
Represents an argument to a constructor or method.
The default context implementations.
The default BeanDefinitionData implementation.
The default BeanDefinitionDataCollector implementation.
Default implementation of BeanResolutionContext.
Binds a String body argument.
Creates channel options.
Loads resources from the classpath.
Default configuration when no other is present.
The default ConfigurationClient implementation.
The default CompositeDiscoveryClient that is activated when caching is disabled.
Default implementation of CookieDecoder that returns the cookies from the request.
Default implementation of the CustomScopeRegistry interface.
The default implementation of the Environment interface.
The default error route info implementation.
Configuration interface for event loop configuration.
The default factory for EventLoopGroup instances.
Factory for creating named event loop groups.
Implementation of ExecutableBeanContextBinder.
Default implementation of the ExecutableBinder interface.
Default implementation of the ExecutorSelector interface that regards methods that return reactive types as non-blocking.
Default implementation of ExtensibleExpressionCompilationContext.
Factory for producing expression evaluation context.
Default implementation of ConfigurableExpressionEvaluationContext.
Loads resources from the file system.
Default implementation of the FunctionDiscoveryClient interface.
Default implementation that will exit using System.exit(int).
Default implementation of HealthAggregator that creates a {status: , description: (optional) , details: } response.
Default implementation of the HttpClient interface based on Netty.
Key used for connection pooling and determining host/port.
Default implementation of HttpClientAddressResolver.
Default implementation of HttpClientBinderRegistry that searches by annotation then by type.
The default configuration if no explicit configuration is specified for an HTTP client.
The default connection pool configuration.
Resolves filters for http clients.
This class will handle subscribing to a stream of HttpContent.
Default implementation that determines if the body argument (if present) does not expect decoding of the request body, that the DefaultHttpContentProcessor should be used, regardless of the content type of the request.
Default implementation of HttpHostResolver.
An annotation to apply to an interface to indicate which implementation is the default implementation.
Default implementation of the interceptor registry interface.
HttpClient implementation for java.net.http.* HTTP Client.
Factory to create java.net.http.* HTTP Clients.
Default implementation of Link.
Abstraction over LoadBalancer lookup.
Default implementation of the LocalFunctionRegistry interface
Default implementation of LoggersManager.
Registry of MediaTypeCodec instances.
Stores message body readers and writers.
The default conversion service.
Default implementation of NettyEmbeddedServerFactory.
Factory for the default implementation of the HttpClient interface based on Netty.
A segment of placeholder resolution.
Default implementation of the RequestBinderRegistry interface.
The default RequestMatcher implementation.
A MethodInterceptor that retries an operation according to the specified Retryable annotation.
Default retry predicate.
A DefaultRouteBuilder implementation for building roots.
Default route data implementation.
A Reactive route data collector.
The default route info implementation.
The default Router implementation.
A meta annotation that can be applied to another annotation to specify a fallback scope of no scope is specified by the user for a bean.
The default implementation to generate Instance IDs.
The default SslConfiguration configuration used if no other configuration is specified.
The default StatusRouteInfo implementation.
A default streamed HTTP request.
A default streamed HTTP response.
The default exception handler used if non-other is found.
The default thread factory used for creating threads in Micronaut.
Default implementation of ThreadInfoMapper that returns the ThreadInfo objects as is.
The binder will try to bind the argument value which wasn't matched by an annotation or a type.
The default UriRouteInfo implementation.
Defines a provider of a default Version.
Simple watch service that simply stops the server if any changes occur.
A default WebSocket HTTP response.
ExecutionFlow that can be completed similar to a CompletableFuture.
Delegate class for ByteBuffer.
Delegate for Streamed HTTP Request.
Delegate for Streamed HTTP Response.
An interface for wrapping a BeanDefinition with another that delegates and potentially decorates the BeanDefinition instance.
An interface for ExecutableMethod instances that delegate to an underlying ExecutableMethod.
Annotation that can be applied to method to signify the method receives a HttpMethod.DELETE.
A method designed to annotate an Endpoint delete operation.
A processor that processes references to Delete operations Endpoint instances.
 
Represents a runtime failure to perform dependency injection.
An interface for types that are described by a description.
Options for controlling the visibility of health details.
Represents ComputeInstanceMetadata for Digital Ocean.
Default configuration for retrieving Digital Ocean metadata for ComputePlatform.DIGITAL_OCEAN.
A enum of Digital Ocean metadata.
Resolves ComputeInstanceMetadata for Digital Ocean.
A NetworkInterface implementation for Digital Ocean.
A ClassWriterOutputVisitor that writes to a target directory.
Data about a disabled bean.
An exception that can be thrown to disable a bean programmatically from within a factory bean.
Main client abstraction used for service discovery.
A health indicator for the discovery client.
Enables the user to enable or disable the health indicator.
A factory class that can be replaced at runtime for creating LoadBalancer instances that load balance between available clients provided by the DiscoveryClient.
A LoadBalancer that uses the DiscoveryClient and a ServiceInstance ID to automatically load balance between discovered clients in a non-blocking manner.
Base class for common discovery configuration options.
Base exception for exceptions thrown by the discovery system.
A HealthIndicator used to display information about the disk space of the server.
Specific configuration properties for the disk space health indicator.
Switch based dispatch writer.
Dispatch target implementation writer.
State carried between different DispatchWriter.DispatchTargets.
Field get dispatch target.
Field set dispatch target.
Interceptable method invocation dispatch target.
Method invocation dispatch target.
A bean definition that provides disposing hooks normally in the form of PreDestroy annotated methods.
Expression node for binary '/' operator.
Expression AST node for double literal.
An exception thrown when multiple routes match a given URI.
Handles exceptions of type DuplicateRouteException.
Placeholder MessageBodyWriter implementation that decides which writer to use based on the dynamic (runtime) type of the body.
This annotation allows driving the production of Bean definitions from presence of other bean definitions.
This annotation allows driving the production of Bean definitions from either configuration or the presence of another bean definition
Builder for ElapseTimeElement.
Stores data about a compile time element.
Element's annotation metadata.
Element's annotation metadata factory.
ElementFactory<E,C extends E,M extends E,F extends E>
A factory for creating elements.
Expression AST node used for method invocation.
An enum of modifier names now tied to the reflection API.
Mutable annotation metadata provider.
An interface for querying the AST for elements.
Result interface when building a query.
Support for the elvis operator.
An EmbeddedApplication is a runnable application that starts and manages the ApplicationContext.
An EmbeddedServer is a general abstraction to manage the lifecycle of any server implementation within a running Micronaut application.
Extended version of the ServiceInstance interface for the EmbeddedServer.
ServerUnderTest implementation for EmbeddedServer.
ServerUnderTestProvider implemntation which returns an instance of EmbeddedServerUnderTest.
Base interface for classes that emit data.
Delegate for Empty HTTP Response.
The empty operator.
An PropertySource that is empty when instantiated.
An exception thrown when the server returned and empty, unreadable response.
The elements query helper.
Defines a management endpoint for a given ID.
An Endpoint configuration.
The default Endpoint configuration.
A condition that checks whether an Endpoint is enabled.
If a bean of type EndpointSensitivityHandler is present the EndpointsFilter is not loaded.
Finds any sensitive endpoints.
Returns 401 for Endpoint requests which have sensitive true.
An annotation mapper that improves introspection for JPA entities.
An annotation mapper that improves reflective access for JPA entities.
EntryPoint is a meta-annotation used on other annotations to indicate that the annotated element is an entry point into the framework from the outside.
A class that can determine the weight of an entry.
Stores data about an element that references a enum constant.
Models an enum type.
The current application environment.
Expression AST node used for retrieving properties from environment at runtime.
Interface for components configurable by the environment.
Endpoint that displays information about the environment and its property sources.
A bean interface that allows hiding or masking of parts of the environment and its property sources when they are displayed in the EnvironmentEndpoint.
This class is passed to an instance of EnvironmentEndpointFilter (if one is defined) each time the EnvironmentEndpoint is invoked.
A mapping from environment variable names to Micronaut property names.
Loads properties from environment variables via System.getenv().
Reads properties from JSON stored in the environment variables SPRING_APPLICATION_JSON or MICRONAUT_APPLICATION_JSON.
Checks if epoll is available.
Creates channel options.
Factory for EpollEventLoopGroup.
Expression AST node for binary '==' operator.
Annotation that can be applied to method to map it to an error route.
Contains information about an error that occurred.
Contains methods to obtain Error and Throwable from an HttpRequest.
A builder for a ErrorContext.
 
 
Creates Http responses that represent errors.
Represents a Route that matches an exception.
Represents a Route that matches an exception.
Interface for reporting conversion errors.
Variation of AnnotationMetadata that is used when evaluated expression in annotation values need to be resolved at runtime.
An EvaluatedAnnotationValue is a AnnotationValue that contains one or more expressions.
Expression included in annotation metadata which can be evaluated at runtime.
Unility methods for used when compiling evaluated expressions.
Set of constants used for evaluated expressions processing.
Interface for evaluated expression parser.
Internal utility class for writing annotation metadata with evaluated expressions.
Wrapper for annotation value, containing evaluated expressions and class name for generated expression class.
Utility class for working with annotation metadata containing evaluated expressions.
Writer for compile-time expressions.
Represents a Server Sent Event.
An Adapter advice annotation that allows listening for events by implementing the ApplicationEventListener interface.
Default event loop group configuration interface.
Factory for EventLoopGroup.
Registry of configured event loops.
A listener registered for notification when an entry is evicted.
Common interface for types that handle exceptions.
A generic hook for handling exceptions that occurs during the execution of an HTTP request.
Annotation applied to the method or type indicating that a ExecutableMethod should be produced for this method.
Represents an executable reference.
Sub-interface of ExecutableBinder that binds arguments from a BeanContext.
An ExecutableBinder is capable of taking a target Executable and fulfilling the argument requirements using the provided binding source and ArgumentBinderRegistry
An executable method is a compile time produced invocation of a method call.
A class capable of processing an ExecutableMethod instances.
Collects a set of executable methods ExecutableMethod.
Writes out a ExecutableMethodsDefinition class.
A TypeElementVisitor that validates primitive types can't have a Nullable annotation.
Annotation used to indicate which executor service a particular task should run on.
The execution flow class represents a data flow which state can be represented as a simple imperative flow or an async/reactive.
Represents a handle to an executable object.
Interface for components that are able to locate and return ExecutionHandle instances for beans.
 
Constructs ExecutorService instances based on UserExecutorConfiguration instances.
Interface that allows customizing the selection of the ExecutorService to run an operation on.
An enum modelling different Executor types that mirror the methods defined in the Executors class.
Annotates a class or method as being experimental and subject to change or removal.
Compilation context is a set of entries which can be referenced in evaluated expression using the '#' sign followed by entry name.
Factory interface for producing expression evaluation context.
Exception throws when problems with expression compilation occur.
Context that can be used by evaluated expression to obtain objects required for evaluation process.
Custom type that simplifies registering a new context class.
Exception thrown on expression evaluation failure.
Abstract evaluated expression AST node.
Exception throws when problems with expression parsing occur.
 
Context class used for compiling expressions.
Metadata for evaluated expression used at compilation time to generate expression class.
This class was created to pass to the GroovyAnnotationMetadataBuilder because the method node the parameter belongs to is not available from the Parameter class itself.
Expression compilation context that can be extended with extra elements.
A factory is a Singleton that produces one or many other bean implementations.
Represents a failure in a Condition.
A Secondary Scope for types that should be used as a fallback.
An exception thrown when an error occurs in the Fallback system.
Stores data about an element that references a field.
Defines an injection point for a field.
Body writer for Files.
Event fired when a file that is being watched changes.
A special type for file handling.
Abstraction to load resources from the file system.
Represents a part of a MediaType.MULTIPART_FORM_DATA request.
Custom condition to only enable file watch if the watch paths exist.
Configuration for the file watch service.
Listener that stops the server if a file changes.
An annotation that can be applied to classes that implement HttpFilter to specify the patterns.
A non-blocking and thread-safe filter chain.
A filter continuation gives can be declared as a parameter on a filter method.
Allows decorating an existing Router with filtering capabilities.
 
Stereotype annotation that helps to link together instance of the filter and http client that filter should be applied to.
Different filter order heuristics, derived from annotations or a bean method.
Dynamic order value (from Ordered.getOrder()).
Fixed order value.
Styles of filter patterns.
 
A filter route is a route that matches an HttpFilter.
The filter runner will start processing the filters in the forward order.
 
Visitor that checks validity of ServerFilter and ClientFilter classes.
A remapper that remaps findbugs annotations to internal annotations.
A LoadBalancer that resolves a fixed URI.
Generic implementation of LocaleResolver for fixed locale resolution.
Expression AST node for float literal.
 
Annotation used to describe the format in the case where the format needs to be altered for the purposes of conversion.
 
Decodes MediaType.MULTIPART_FORM_DATA in a non-blocking manner.
Special HttpBody that "demultiplexes" form data.
Allows introspecting whether the request is a full http request.
Wraps a Netty FullHttpResponse for consumption by the HttpClient.
Allows executing functions from the CLI.
An annotation applied to classes that should be exposed as functions.
The FunctionClient annotation allows applying introduction advise to an interface such that methods defined by the interface become invokers of remote or local functions configured by the application.
Implements advice for the FunctionClient annotation.
Represents a discovered function definition.
Interface for a type that provides function definitions.
An interface for discovery functions, either remote or local.
An exception thrown when an error occurs in the function system.
 
Allows executing the function configured by LocalFunctionRegistry.FUNCTION_NAME
A strategy interface for handling exiting from a function when it is executed via the CLI.
A super class that can be used to initialize a function.
 
Strategy interface for choosing a FunctionInvoker.
An exception thrown when no function can be found.
A marker annotation for methods that are generated though an annotation processor.
A common interface to allow referencing a generated file in either Groovy or Java.
Captures a generic Argument.
Represents a generic element that can appear as a type argument.
Base interface for different filter types.
"Legacy" filter, i.e.
Wrapper around a filter that signifies the filter should be run asynchronously on the given executor.
Last item in a filter chain, called when all other filters are done.
Terminal filter that accepts a reactive type.
Extends Argument to allow differentiating the variable name from the argument name in cases where this is required (parameters and fields for example).
Represents a generic placeholder in source code.
The element annotation metadata for generic placeholder element.
Resource with indeterminate structure.
Utility methods for dealing with generic types via reflection.
Utility methods for dealing with generic type signatures.
Annotation that can be applied to method to signify the method receives a HttpMethod.GET.
An InfoSource that retrieves info from Git properties.
Interface that allows dynamic configuration of reflection generated by the GraalTypeElementVisitor.
Context object for the configuration.
Generates the GraalVM reflect.json file at compilation time.
Groovy implementation of AbstractAnnotationMetadataBuilder.
A class element returning data from a ClassNode.
A ConstructorElement for Groovy.
Groovy element annotation metadata factory.
Implementation of ElementFactory for Groovy.
A enum constant element returning data from a Variable.
A field element returning data from a FieldNode.
A method element returning data from a MethodNode.
Groovy's native element.
The class element.
The class element with an owner (Generic type etc.).
The field element.
The method element.
The package element.
The parameter element.
The placeholder element.
A class element returning data from a PackageNode.
Implementation of ParameterElement for Groovy.
The visitor context when visiting Groovy code.
Expression AST node for binary '>=' operator.
Expression AST node for binary '>' operator.
Subscriber that publishes received messages to the handler pipeline.
Creates Hateoas JSON error responses.
Annotation that can be applied to method to signify the method receives a HttpMethod.HEAD.
An annotation that can be applied to method argument to indicate that the method argument is bound from an HTTP header This also can be used in conjunction with @Headers to list headers on a client class that will always be applied.
An AnnotatedArgumentBinder implementation that uses the Header annotation to trigger binding from an HTTP header.
An AnnotatedClientRequestBinder implementation for Header.
Builder for Headerlement and HeadersElement.
Common interface for all headers types.
This lets you declare several headers for a client class and have them always included.
 
A RequestVersionResolver responsible for extracting version from HttpHeaders.
Configuration for version resolution via headers.
Aggregates all registered health indicators into a single response.
Options for HealthEndpoint selector that aggregates HealthIndicator according to Liveness respectively Readiness qualifiers.
Exposes an Endpoint to provide information about the health of the application.
Configuration related to handling of the HealthStatus.
Describes an indicator of health of the application.
This class provides a set of common constants to indicate the level of detail to be included in the Health status response.
A continuous health monitor that that updates the CurrentHealthStatus in a background thread.
Used to represent the output of a HealthIndicator.
Helper class to build instances.
A filter that matches the HealthEndpoint and returns an appropriate HTTP status code.
The status of a health indicator.
 
Configuration for heart beat.
Custom condition to conditionally enable the heart beat.
Annotation that expresses the requirements for enabling the heart beat.
A heartbeat event is an event fired periodically and configured by HeartbeatConfiguration.
A scheduled task that sends a periodic heartbeat whilst the server is active.
 
A contract for a publisher that buffers data to allow for the release of that data if there will not be a subscriber.
Extended version of InterceptedProxy that allows swapping out the previous instance.
 
Provides an abstract class which implements LocaleResolver and handles default locale resolution.
Logging handler for HTTP access logs.
Common HTTP attributes.
Base type for a representation of an HTTP request body.
A non-blocking HTTP client interface designed around the Micronaut API and Reactive Streams.
Resolves the client IP address from the request.
A registry of ClientArgumentRequestBinder instances.
Configuration for the HttpClient.
Configuration for the HTTP client connnection pool.
Strategy interface for decoding the error from a server respponse.
Parent class for all HTTP client exceptions.
Utility Class to work with HttpClientException.
A factory to create HTTP clients.
An HttpClientFilter extends HttpFilter and allows the passed request to be mutated.
Subinterface for filter resolution specific to HTTP client filters.
Introduction advice that implements the Client annotation.
Interface for managing the construction and lifecycle of instances of HttpClient clients.
An exception that occurs when a response returns an error code equal to or greater than 400.
Determines if a given http message should be compressed.
Deprecated.
Use the MessageBodyReader API instead
Utility class for transforming a NettyHttpRequest using a HttpContentProcessor to a Publisher.
Note: A more complicated, but possibly faster, implementation of this class is archived in the original PR.
Responsible for determining which HttpContentProcessor to use to process the body of the request.
Interface that allows plugging into the constructor of the HttpContent subscriber.
Utility methods for generated HTTP content.
Converter registrar for HTTP classes.
Parent class of all exceptions thrown during HTTP processing.
A interface for classes that can intercept and filter HttpRequest instances and can either proceed with the request or return a modified result.
A contract for resolving filters for a given request.
A resolved filter entry.
Generic implementation of LocaleResolver for fixed locale resolution.
A FunctionExecutor that uses a HttpClient to execute a remote function definition.
Constants for common HTTP headers.
Adapter from HttpHeaders into HttpHeaders.
Utility class to work with HttpHeaders or HTTP Headers.
Interface for common HTTP header values.
Resolves the host name of the current server.
Configuration for Locale Resolution in a HTTP Request.
Responsible for determining the current locale from a request.
A RequestScope which uses the current HttpRequest to resolve the locale and hence return the localized messages.
Common interface for HTTP messages.
A wrapper around an HttpMessage.
An enum containing the valid HTTP methods.
A meta annotation for HTTP Controller actions.
Represents HTTP query parameters parsed from the HttpRequest.getUri().
Common interface for HTTP request implementations.
Utility class to create HttpRequest.Builder from a Micronaut HTTP Request.
A factory interface for MutableHttpRequest objects.
An event fired when an HttpRequest is received by the server.
An event fired when an HttpRequest is finalized by the server.
A wrapper around a HttpRequest.
Common interface for HTTP response implementations.
Adapter from HttpResponse to HttpResponse.
Utility class to verify assertions given an HTTP Response.
HTTP Response Assertion Builder.
A factory interface for creating MutableHttpResponse instances.
A contract to provide an http response.
A wrapper around a HttpResponse.
A base ConfigurationProperties for servers.
Configuration for CORS.
Configuration for host resolution with the HttpHostResolver.
Configuration for locale resolution used by HttpLocaleResolver.
Configuration for multipart handling.
Exceptions related to the HTTP server.
An HttpServerFilter extends HttpFilter and provides the response as a MutableHttpResponse.
 
Subinterface for filter resolution specific to HTTP server filters.
 
 
Represents HTTP status codes.
Exception thrown to return a specific HttpStatus and an error message.
Handles exception of type HttpStatusException.
Provide type information for HTTP response.
Utility methods for HTTP handling.
Enum representing different HTTP versions.
This class collects information about HTTP client protocol version settings, such as the HttpVersionSelection.PlaintextMode and the ALPN configuration.
The connection mode to use for plaintext (non-TLS) connections.
The default RouteBuilder.UriNamingStrategy if none is provided by the application.
Fully buffered ByteBody, all operations are eager.
Immediate MultiObjectBody, all operations are eager.
HttpBody that contains a single object.
Immutable variant of ArgumentConversionContext that can be used as a constant in cases where conversion error handling and rejection is not required.
The imperative execution flow.
Allows importing an already compiled set of beans, placing any generating beans relative to the class where the import annotation is defined.
An annotation that can be used on types where there may be many implementations of a particular interface.
Allows Indexed to be repeatable.
Aggregates all registered info sources into a single response.
Exposes an Endpoint to provide information about the application.
Describes an source of info that will be retrieved by the InfoEndpoint.
Infrastructure scope represents a bean that cannot be overridden or replaced because it is critical to the functioning of the system.
A marker interface for BeanContext implementations that can be introspected, that is to say for context which can be created and need to be fully configured, but not necessarily started yet.
A bean definition that is provides initialization hooks normally in the form of methods annotated with PostConstruct.
An type of BeanDefinition that supports post initialization bean dependencies injection.
Shared interface for injectable elements.
An injection point as a point in a class definition where dependency injection is required.
An annotation that can be declared on a constructor or method parameter that indicates that the injected bean should be destroyed after injection completes.
Extended version of GroovyClassLoader that can be used to test dependency injection compilation.
Utility class for testing Groovy visitors.
Body writer for InputStreams.
Expression AST node for 'instanceof' operator.
An type of BeanDefinition that can build a new instance.
An annotation that can be used on another annotation member that returns a class to indicate that the value of the annotation should be populated as an instance of the specified class.
Thrown when an error occurs instantiating an instance.
Utility methods for instantiating objects.
An Executor that has been instrumented to allow for propagation of thread state and other instrumentation related tasks.
An ExecutorService that has been instrumented to allow for propagation of thread state and other instrumentation related tasks.
A ScheduledExecutorService that has been instrumented.
An interface implemented by generated proxy classes.
An internal interface implemented by generated proxy classes.
An internal InterceptedBean that proxies another instance.
The intercept method supporting intercepting different reactive invocations.
Possible result types.
The InterceptedMethod utils class.
A Intercepted that proxies another instance.
An Interceptor intercepts the execution of a method allowing cross cutting behaviour to be applied to a method's execution.
A meta-annotation that can be used on MethodInterceptor declarations to specify the InterceptorBinding and make the type a bean.
An InterceptorBinding is used as a meta-annotation on Around and Introduction advice to indicate that AOP advice should be applied to the method and that any annotations that feature this stereotype annotation should be used to resolve associated interceptors at runtime.
Repeatable wrapper for InterceptorBinding.
The remapped for various interceptor annotation stereotypes.
Qualifier used to resolve the interceptor binding when injection method interceptors for AOP.
An internal representation of the Interceptor chain.
Enum representing different interceptors kinds.
Strategy interface for looking up interceptors from the bean context.
Registers the InterceptorRegistry instance.
Interceptor classes implement the Ordered interface in order to control the order of execution when multiple interceptors are present.
Annotates a class or method regarded as internal and not for public consumption.
Logs warnings during compilation if any class extends an internal or experimental Micronaut API.
Thrown for an unrecoverable server exceptions.
Expression AST node for integer literal.
Marker interface for instances that are implemented automatically via Introduction advise.
Introduction advice allows interfaces and abstract classes to be implemented at compile time by MethodInterceptor implementations.
An annotation that indicates a type should produce a BeanIntrospection at compilation time.
The access type for bean properties.
Allow pre-computed indexes for property lookups based on an annotation and a member.
Configuration for an introspection builder.
Visibility policy for bean properties and fields.
Map values of Introspected to BeanProperties.
A TypeElementVisitor that visits classes annotated with Introspected and produces BeanIntrospectionReference instances at compilation time.
Thrown when an error occurs introspecting a bean type.
An InvocationContext passed to one or many Interceptor instances.
Runtime exception equivalent of InvocationTargetException.
Utility to use a BiFunction which throws internally a IOException.
Configures the default I/O thread pool if none is configured by the user.
Checks if io-uring is available.
Factory for IOUringEventLoopGroup.
Utility methods for I/O operations.
Configuration for the Jackson JSON parser.
Converter registrar for Jackson.
Helper class for implementing JsonMapper.readValue(ByteBuffer, Argument) with optimizations for netty ByteBufs.
A Reactive streams publisher that publishes a JsonNode once the JSON has been fully consumed.
jackson-databind implementation of JsonMapper.
Implementation of JsonMapperSupplier for Jackson.
The pre instantiate callback.
Default exception handler for jackson processing errors.
Annotation that can be applied to types that use Jackson to customize serialization features.
Stores features to later configure an ObjectMapper.
A MediaTypeCodec for JSON and Jackson.
An implementation of the ObjectSerializer interface for Jackson.
A Reactive streams publisher that publishes a JsonNode once the JSON has been fully consumed.
An annotation mapper that improves introspection for JPA entities.
Handle mapped super class.
Allows using the `jakarta.persistence.PersistenceContext` annotation in Micronaut.
Implementation for Jakarta bean lookups.
A AnnotationMetadata for builder for Java to be used at compile time.
A class element returning data from a TypeElement.
Java element annotation metadata factory.
An implementation of ElementFactory for Java.
A method element returning data from a ExecutableElement.
Utility methods for Java model handling.
The Java native element.
The class native element.
The method native element.
The package native element.
The class native element.
The variable native element.
A package element for Java.
Utility for parsing Java code.
The visitor context when visiting Java code.
A transformer that remaps javax.annotation.Nonnull to AnnotationUtil.NON_NULL.
A transformer that remaps javax.annotation.Nullable to AnnotationUtil.NULLABLE.
Allows using the `javax.persistence.PersistenceContext` annotation in Micronaut.
Transforms javax.annotation.PostConstruct into the javax meta-annotation AnnotationUtil.POST_CONSTRUCT.
Transforms javax.annotation.PreDestroy into the javax meta-annotation AnnotationUtil.PRE_DESTROY.
Implementation for javax provider bean lookups.
Remaps from javax.inject to jakarta.inject.
A HealthIndicator used to display information about the jdbc status.
HttpClient implementation for java.net.http.* HTTP Client.
The Javanet implementation of SslBuilder that generates an SSLContext to create a client that supports SSL.
Marker interface for HttpClient implementations that use the java.net.http.* HTTP Client.
Factory to create java.net.http.* HTTP Clients.
A ObjectSerializer that uses JDK serialization.
A transformer that remaps org.eclipse.jdt.annotation.Nullable to javax.annotation.Nullable.
Public to allow special handling for conversion service.
Exception handler interface that converts json binding exceptions to more specific ConversionErrorExceptions.
 
 
Base interface for application-level json configuration.
A ConfigurationMetadataWriter that writes out metadata in the format defined by spring-configuration-metadata.json.
This class will handle subscribing to a JSON stream and binding once the events are complete in a non-blocking manner.
Converter registrar for json.
This class takes in JSON data and does simple parsing to detect boundaries between json nodes.
A region that contains a JSON node.
Makes every use of Jackson's JsonCreator also represent a Creator.
A class that can be used to represent JSON errors that complies to Vnd.Error without the content type requirements.
Default exception handler for JSON processing errors.
Base interface for json feature classes that can be scanned from annotations.
Builds the Subscriber for JSON requests.
Common abstraction for mapping json to data structures.
Strategy interface for resolving a JsonMapper.
A MediaTypeCodec for JSON and Jackson.
A MediaTypeCodec for JSON and Jackson.
Body handler for JSON.
Immutable class representing a json node.
Simple facade over a JsonNode to make it a ConvertibleValues.
Deserializer for JsonNode.
Serializer for JsonNode.
Codec for transforming JsonNode from and to json streams.
Public to allow special handling for conversion service.
An implementation of the ObjectSerializer interface for Jackson.
A PropertySourceLoader that reads application.json files if they exist.
A PropertySourceLoader that reads application.json files if they exist.
Configuration for json stream parsing and generation.
Utility functions for transferring from a JsonParser to a JsonGenerator.
A Reactor subscriber used to handle JSON content.
Exception thrown when there is a syntax error in JSON (e.g.
Jackson @JsonView filter.
A transformer that remaps org.jspecify.annotations.Nullable to javax.annotation.Nullable.
 
Allows treating the Kotlin deprecated annotation as the Java one.
Internal Utility methods for working with Kotlin suspend functions
Kotlin's InterceptedMethod with extra methods to access coroutine's context.
An annotation mapper that maps Kotlin's NotNull to a common annotation.
An annotation mapper that maps Kotlin's Nullable to a common annotation.
Represents a Kotlin parameter to a method or constructor.
Internal Utility methods for working with Kotlin suspend functions
Checks if kqueue is available.
Creates channel options.
Factory for KQueueEventLoopGroup.
A property source specific for the Kubernetes environment.
Lazily parsed JsonNode.
A life cycle interface providing a start method and extending Closeable which provides a close() method for termination.
Interface for a hateoas link.
Build for creating Link instances.
Qualifier designed to make the HealthIndicator exposed via /health/liveness endpoint of HealthEndpoint.
Interface to abstract server selection.
Converters from URL to LoadBalancer interface.
A resolver of LoadBalancer instances that are capable of resolving references to services into a concrete loadbalance.
Used to store a reference to an underlying TypeElementVisitor and optionally invoke the visit methods on the visitor if it matches the element being visited by the annotation processor.
Binds Locale arguments in controller methods using the LocaleResolver.
Locale resolution configuration.
Responsible for determining the current locale given a context.
 
 
A registry of defined FunctionBean instances containing within the current running application.
Builder for LocalHostElement.
Builder for LocalIpElement.
Retrieve messages for the resolved locale.
Builder for LocalPortElement.
An implementation of LoggingSystem that works with Log4j.
An implementation of ManagedLoggingSystem that works with logback.
An implementation of LoggingSystem that works with logback.
An implementation of ManagedLoggingSystem that works with logback.
Utility methods to configure LoggerContext.
Represents a http request or response element.
Events.
Builder for LogElement.
Represents the configuration of a ManagedLoggingSystem logger.
Exposes an Endpoint to manage loggers.
Used to retrieve and update logger information for the LoggersEndpoint.
Abstraction for a logging system.
Thrown when something goes wrong on Logging System.
Abstract expression AST node for binary logical operator.
Logging levels supported by a LoggingSystem Typically, a logging system may permit the log level to be null, representing an unspecified log level.
Expression AST node for long literal.
 
Condition that only matches if virtual threads are supported on this platform.
Expression AST node for binary '<=' operator.
Expression AST node for binary '<' operator.
A factory that creates the WatchService.
Replaces the DefaultWatchThread for Mac OS X to use native file watch.
Abstraction for a logging system.
Allows configuration how map property values are injected.
Specifies the type of the map that should be injected.
Handle mapped super class.
An annotation that can be used on abstract methods that define a return type and exactly a single argument.
The conflict strategy specifies the behaviour if a conflict is found.
The mappings.
Handles the mapper annotation.
A MediaTypeCodec for JsonMapper based implementations.
The mapper visitor.
Abstract annotation metadata delegate for cases when annotation values need to be mapped before being returned.
A PropertyResolver that resolves values from a backing map.
A PropertySource that uses a map.
Expression AST node for regex 'matches' operator.
Abstract expression AST node for binary math operations on primitive types.
MDC propagation.
Represents a media type.
Represents a codec for a particular media type.
A registry of decoders.
A bean for the default MediaTypeCodecRegistry used by the server.
The media type converters registrar.
Interface for bodies that provide their own media type.
A member element is an element that is contained within a ClassElement.
An exception thrown when a message is being acknowledged or rejected.
An annotation that can be applied to method argument to indicate that the method argument is bound from message body.
Exception that occurs when reading or writing a message body.
A handler combines a reader and a writer.
An interface that allows reading a message body from the client or the server.
An interface that allows writing a message body for the client or the server.
An annotation that can be applied to method argument to indicate that the method argument is bound from a message header.
This lets you declare several headers for a client class and have them always included.
Generic container object for message headers.
Generic stereotype annotation that should be applied to other annotations that indicate to Micronaut, which classes are message listeners.
An exception thrown when an unrecoverable error occurs with a MessageListener.
Generic stereotype annotation that models a mapping of a message listener onto a target destination, whether that be a queue a topic or whatever.
Generic messaging meta-annotation to indicate a type that is a message producer.
Interface for resolving messages from some source.
The context to use.
Utility class used by MessageSource to create variables maps.
An alternative EmbeddedApplication that gets activated for messaging applications when no other application is present.
An exception thrown when an unrecoverable error occurs with a messaging client.
General parent exception for all message related exceptions.
An exception thrown when an unrecoverable error occurs with the messaging system.
Represents a route that is backed by a method.
Match a route based on a method.
Represents the built in conventions for mapping a method name to an HTTP Method and URI.
Stores data about an element that references a method.
The element annotation metadata for a method element.
The helper class to implement method element annotations.
Represents an execution handle that invokes a method.
Defines an injection point for a method.
A MethodInterceptor extends the generic Interceptor and provides an interface more specific to method interception.
An internal representation of the Interceptor chain.
Extended version of InvocationContext for MethodInterceptor instances.
A reference to a method.
Main entry point for running a Micronaut application.
Default implementation of Banner that prints the default Micronaut banner.
Micronaut deserializers for jackson.
MicronautHttpData<D extends io.netty.handler.codec.http.multipart.HttpData>
Alternate HttpData implementation with some limited concurrency support.
Factory for MicronautHttpData instances.
 
 
Validates all route uri variables are present in the route arguments.
Provides utility method for working with the annotation processor AST.
Expression AST node for binary '/' operator.
Expression node for binary '*' operator.
A body consisting of multiple objects of arbitrary type.
A builder class to generate a list of parts for a multipart request.
Represents the body of a multipart request that emits each part after it is received in its entirety.
A builder class to add different Part to MultipartBody.
A Body argument binder for a MultipartBody argument.
A factory for Multipart data.
Exception thrown during multipart handling.
A factory for creation of various FormattingTypeConverters to and from ConvertibleMultiValues type.
An abstract class to convert to ConvertibleMultiValues.
A converter from Iterable to ConvertibleMultiValues.
A converter from Map to ConvertibleMultiValues.
A converter to convert from ConvertibleMultiValues to an Iterable.
A converter to convert from ConvertibleMultiValues to an Map.
A converter to convert from ConvertibleMultiValues to a POJO Object.
A converter from generic Object to ConvertibleMultiValues.
A mutable various of DefaultAnnotationMetadata that is used only at build time.
Mutable annotation metadata.
A mutable version of the ArgumentValue interface.
An interface for types that support mutating attributes.
A version of ConversionService that supports adding new converters.
 
Implementation of MutableConvertibleMultiValues that operates against a backing LinkedHashMap.
A ConvertibleValues that is mutable.
Mutable version of ConvertibleMultiValuesMap.
Common interface for all mutable header types.
Extends HttpHeaders add methods for mutation of headers.
An interface for an HttpMessage that is mutable allowing headers and the message body to be set.
Mutable version of HttpParameters which allows adding new parameters.
An extended version of HttpRequest that allows mutating headers, the body etc.
A version of the HttpResponse interface that is mutable allowing the ability to set headers, character encoding etc.
Mutable propagated context will modify the internal context Intended for use-cases when the propagated context needs to be mutated and propagated later.
The mutated element annotation metadata for a method element.
An interface for components that are named.
A named AnnotationMapper operates against any named annotation, and does not require the annotation to be on the annotation processor classpath.
A named AnnotationTransformer operates against any named annotation, and does not require the annotation to be on the annotation processor classpath.
Client versioning configuration for named configurations nested under micronaut.http.client.versioning.
An interface for a components that resolve names.
Naming convention utilities.
Expression node for unary '-' operator.
Expression AST node for binary '!=' operator.
Netty-specific writer.
A ByteBufferFactory implementation for Netty.
Different netty channel types.
Interface implemented by users to hook into the pipeline setup of the netty HTTP client.
Enum to describe the role of the channel passed to NettyClientCustomizer.specializeForChannel(Channel, ChannelRole).
Interface implemented by the HTTP client registry to register customizers.
Default implementation of MutableHttpRequest for the HttpClient.
Implementation of the HttpRequestFactory interface for Netty.
The Netty implementation of SslBuilder that generates an SslContext to create a client that supports SSL.
This class is not final, so you can extend and replace it to implement alternate mechanisms for loading the key and trust stores.
A delegation of the Netty Attribute to implement the CompletedPart contract.
A Netty implementation of CompletedFileUpload.
Factory for bytebuf related converters.
Factory for bytebuf related converters that do not need the application context (can be registered with SPI).
A wrapper around a Netty cookie.
A cookie decoder that extracts cookies from the NettyClientHttpRequest if it is present.
A CookieFactory for constructing Cookie instances for Netty.
Delegates to Cookie.
Extended EmbeddedServer interface that represents a Netty-based HTTP server.
A factory / strategy interface for creating instances of NettyEmbeddedServer.
Internal interface with services required by the NettyHttpServer.
Allows configuring Netty global properties.
A factory to create Netty HTTP clients.
Delegates to Netty's HttpHeaders.
Implementation of MutableHttpParameters for Netty.
Delegates to the Netty HttpRequest instance.
Common interface for client and server to implement to construct the Netty versions of the request objects.
Common interface for client and server to implement to construct the Netty versions of the response objects.
Implementation of HttpResponseFactory for Netty.
Implements the bootstrap and configuration logic for the Netty implementation of EmbeddedServer.
Allows configuring Netty within NettyHttpServer.
Access logger configuration.
Abstract class for configuring the Netty event loop.
Allows configuration of properties for the AbstractFileBodyWriter.
Configuration for the Cache-Control header.
Http2 settings.
Configuration for the experimental HTTP/3 server.
Sets the manner in which the HTTP server is configured to receive requests.
Netty listener configuration.
Address family enum.
Configuration for Netty parent.
Configuration for Netty worker.
Replacement for JsonMessageHandler with ChunkedMessageBodyReader support.
Netty json stream implementation for MessageBodyHandler.
Delegates to Netty's FullHttpResponse.
A Netty implementation of PartData.
A version of RequestArgumentBinder that requires NettyHttpRequest.
Interface implemented by users to hook into the pipeline setup of the netty HTTP server.
Enum to describe the role of the channel passed to NettyServerCustomizer.specializeForChannel(Channel, ChannelRole).
Interface implemented by the HTTP server to register customizers.
A Netty request binder registry.
Netty implementation of WebSocketBroadcaster.
A handler for WebSocketFrame instances.
Handles WebSocket upgrade requests.
An implementation of the StreamingFileUpload interface for Netty.
Factory for instances of NettyStreamingFileUpload.
The Default thread factory the Netty NioEventLoopGroup will use within Micronaut to create threads.
Common utilities for netty TLS support.
Handler for WebSocket clients.
Implementation of the WebSocketSession interface for Netty.
Netty-specific writer implementation.
This interface is used to write the different kinds of netty responses.
Represents information about a network interface in the Cloud.
Documents the code change that needs to be done in the next major version.
Factory for NioEventLoopGroup.
An exception thrown when no service is available.
Thrown when a request is made that has no host information.
Excludes a member of an annotation type (such as a qualifier type or interceptor binding type) from consideration when the container compares two annotation instances.
A marker annotation for methods that are non-blocking.
A marker interface for argument binders that are non-blocking.
A common annotation to declare that annotated elements cannot be null.
Exception thrown when a bean is not unique and has multiple possible implementations for a given bean type.
Thrown when no such beans exists.
Thrown if an error occurs locating a message.
Builder for not implemented tokens.
Expression node for unary '!' operator.
A common annotation to declare that annotated elements can be null under some circumstance.
Validates route parameters are nullable or optional for optional template variables.
Expression AST node for null literal.
Expression AST node for relational operations (>, <, >=, <=) on numeric types.
Factory bean for creating the Jackson ObjectMapper.
Simple facade over a Jackson ObjectNode to make it a ConvertibleValues.
Interface for implementations capable of serializing objects.
Utility methods for working with objects
 
Annotation that can be applied to a method that will receive WebSocket close frames.
Expression AST node for array instantiation.
Annotation that can be applied to a method that will receive WebSocket errors.
Annotation that can be applied to a method that will receive WebSocket message frames.
Annotation that can be applied to a method that will receive WebSocket open frames.
Details of the current operating system.
Represents a command line option.
An OptionalValues that for each key features an Optional List of values.
A simple type safe abstraction over a map of optional values.
Default implementation of OptionalValues.
A Jackson Serializer for OptionalValues.
Annotation that can be applied to method to signify the method receives a HttpMethod.OPTIONS.
Annotation for objects that are ordered.
Interface for objects that are ordered.
Apply the Ordered interface to lists or arrays.
Interface for types that provide originating elements.
Expression node for binary '||' operator.
Defines a utility class which evaluates if a HttpRequest should be processed.
Implementation of OutgoingHttpRequestProcessor.
Defines regular expressions to match requests.
An annotation processor that generates BeanConfiguration implementations for each package annotated with Configuration.
Models a package in source code.
A AnnotationRemapper that simply renames packages retaining the original simple class names as is.
A hint annotation that can be added to Bean definitions or Executable methods to indicate that they can be initialized in parallel with the application context.
Specifies that an argument to a bean constructor is user provided.
Represents a parameter to a method or constructor.
 
A RequestVersionResolver responsible for extracting version from HttpParameters.
Configuration for version resolution via request parameters.
An type of BeanDefinition that can build a new instance, construction requires additional (possibly user supplied) parameters in order construct a bean
An extended version of the Provider interface.
Exception that is thrown in command line parsing fails.
Methods to parse Java source files.
An annotation that can be applied to method argument to indicate that the method argument is bound from a specific part of a "multipart/form-data" request.
Skips binding parts because they should be handled by a multipart processor.
Represents a chunk of data belonging to a part of a multipart request.
Annotation that can be applied to method to signify the method receives a HttpMethod.PATCH.
Interface for components that can match source strings against a specified pattern string.
Used to bind a parameter exclusively from a path variable.
Used for binding a parameter exclusively from a path variable.
A variation of ArgumentBinder.BindingResult that indicates that the binding result is pending and the value should be checked later.
Netty handler that handles incoming HttpRequests and forwards them to a RequestHandler.
Expression node for unary '+' operator.
Annotation that can be applied to method to signify the method receives a HttpMethod.POST.
Marker interface for RequestArgumentBinder to indicate that it should bind after filters are applied.
Exception to indicate postponing processing to next round.
Expression AST node for '^' operator.
A Qualifier that indicates that this bean is the primary bean that should be selected in the case of multiple possible interface implementations.
A qualifier to lookup a primary bean.
A ClassElement of primitive types.
The exception can be used to stop the processing and display an error associated to the element.
An annotation to indicate the MediaTypes produced by a particular component.
A Bean Qualifier that qualifies based on the value of the media type defined in the Produces annotation.
The propagation across different threads using the context which is immutable and can be extended/reduced by different elements.
Context propagation AutoCloseable to be used in try-resource block.
Propagated element of PropagatedContext.
Extends InfoEndpoint to add a helper method for retrieving a PropertySource from a properties file.
Default load that handles Java properties files.
A property that can be contained within a PropertySource or used generally throughout the system.
Expression AST node used for accessing object property.
Typical conventions used for property names through the system.
A property element represents a JavaBean property on a ClassElement.
The access type for bean properties.
The element annotation metadata for property element.
Represents a query for PropertyElement definitions.
The property expression resolver.
Metadata about a property.
Thrown when a property cannot be resolved.
Interface for implementations that resolve placeholders in configuration and annotations.
A property resolver is capable of resolving properties from an underlying property source.
An annotation that can be used on either the main class or a test to provide additional hard coded property values to the Environment.
A PropertySource is a location to resolve property values from.
Property convention.
Loads the given property source for the given environment.
An interface for beans that are capable of locating a PropertySource instance.
A PropertyResolver that resolves from one or many PropertySource instances.
The property catalog to use.
Interface for classes that read and process properties sources.
Prototype scope is a non-singleton scope that creates a new bean for every injection point.
Deprecated.
Use the typed member of the Bean annotation instead
Makes TypeInformation.isWrapperType() return true for Providers.
Helper methods for dealing with Provider.
Marker interface for a BeanDefinition that is an AOP proxy.
Responsible for parsing and returning the information stored in the standard and de facto standard proxy headers.
Interface that allows proxying of HTTP requests in controllers and filters.
A factory to create Proxy HTTP clients.
Interface for managing the construction and lifecycle of instances of ProxyHttpClient clients.
Extends BeanDefinitionVisitor and adds access to the proxied type name.
Further options for ProxyHttpClient when handling proxy requests.
Builder class.
Utility visitor that only visits public abstract methods that have not been implemented by the given type.
An adapter that implements all methods of the TypeVisitor interface subclasses can selectively override.
 
Utilities for working with raw Publisher instances.
A publisher for a value.
A publisher that throws an error.
Maps the next result or supplies an empty result.
Marker interface for any micronaut produced publishers.
Static optimizations for the class.
A HttpRequest that is potentially capable of HTTP2 server push.
Annotation that can be applied to method to signify the method receives a HttpMethod.PUT.
Internal interface used by generated code to propagate qualifiers.
An interface for a BeanType that allows qualifiers.
Used to qualify which bean to select in the case of multiple possible options.
The remapped adds a non-binding attribute to any qualifiers that are stereotypes.
Factory for Bean qualifiers.
Indicates that the parameter to a method should be bound from a value in the query string or path of the URI.
A binder for binding arguments annotated with @QueryValue.
Implementation of the Binder for QueryValue The details of implementation can be found in the QueryValueClientArgumentRequestBinder.bind(ArgumentConversionContext, ClientRequestUriContext, Object, MutableHttpRequest) method javadoc.
The property expression for random values.
A body handler that is responsible for "raw" writing/reading, i.e.
Allows hooking modifying the resulting publisher prior to returning it from the client.
The reactive execution flow.
Default implementation of InfoAggregator.
Reactive propagation of PropagatedContext.
Implementation of TypeInformationProvider for reactive streams.
Registers converters for Reactive types such as Publisher.
A transformer that remaps io.reactivex.annotations.Nullable to javax.annotation.Nullable.
A transformer that remaps reactor.util.annotation.Nullable to javax.annotation.Nullable.
Reactor propagation of PropagatedContext.
A method designed to annotate an Endpoint read operation.
Abstraction over File and URL based I/O.
Used by ReadableBytesTypeConverter to parse strings in the form 1MB to numbers.
Converts String's to readable bytes.
A processor that processes references to Read operations Endpoint instances.
Qualifier designed to make the HealthIndicator exposed via /health/readiness endpoint of HealthEndpoint.
An exception thrown when a read timeout occurs.
AOP around advice that can be applied to any type or method that requires Fallback handling.
A MethodInterceptor that will attempt to execute a Fallback when the target method is in an error state.
 
An annotation that models directly the GraalVM reflect-config.json format.
Wrapper annotation.
Field configuration.
Method configuration.
Utility methods for reflection related tasks.
Descriptive annotation that can be used to declare a field, method, constructor and types for reflective access.
A custom scope that allows target beans to be refreshed.
Exposes an Endpoint to refresh application state via a RefreshEvent.
An ApplicationEvent for handling refreshes.
A convenience interface that can be implemented if a component needs to listen for RefreshEvent where the implementation is only interested in a limited set of configuration prefixes.
A MethodInterceptor that will lock the bean preventing it from being destroyed by a RefreshEvent until the method completes.
Implementation of Refreshable.
PathMatcher implementation for regex-style patterns.
Common configuration for ServiceInstance registration.
Exception thrown during ServiceInstance registration.
Abstract expression AST node for relational operations.
 
Builder for RemoteHostElement.
Builder for RemoteIpElement.
Allows a bean to specify that it replaces another bean.
A binder that binds from an HttpRequest.
A class containing methods to aid in satisfying arguments of a Route.
An annotation that can be applied to method arguments to indicate that the method argument is bound to an HTTP request attribute This can also be used in conjuction with @RequestAttributes to list attributes on a client class that will always be applied Note: Request attributes are intended for internal data sharing only, and are not attached to the outbound request.
An AnnotatedArgumentBinder implementation that uses the RequestAttribute annotation to trigger binding from an HTTP request attribute.
This lets you declare several attributes for a client class and have them always included.
An interface that may be implemented by RequestScope beans to allow access to the current request.
Used to bind Bindable parameters to a Bean object.
Used to bind Bindable parameters to a Bean object.
Validates RequestBean parameters.
A ArgumentBinderRegistry where the source of binding is a HttpRequest.
An expression evaluation context for use with HTTP annotations and the condition member.
Method annotation for a request filter.
 
 
 
 
Handler for incoming requests.
This class handles the full route processing lifecycle for a request.
Builder for RequestLineElement.
A locale resolver which resolves the locale via HttpRequest.getLocale().
Route with a request predicate.
Builder for RequestMethodElement.
Builder for RequestProtocolElement.
A CustomScope that creates a new bean for every HTTP request.
Allows defining an HttpRequest based on some property of the server (ie: Port).
 
Builder for RequestUriElement.
Interface responsible for extracting request version from HttpRequest.
For specifying multiple requirements.
Expresses a requirement for a bean or Configuration.
Used to express an operating system family.
Used to express a required SDK version.
An abstract Condition implementation that is based on the presence of Requires annotation.
Internal method marks a type, method or a field for validation.
Represents a REST resource in a hateoas architecture.
Prints a banner from a resource.
A message source backed by a resource bundle.
 
Basic abstraction over resource loading.
Creates beans for ResourceLoaders to handle static resource requests.
Modifies deserialization for Resource.
Resolves resources from a set of ResourceLoader instances.
A resource route is a composite route to a REST endpoint.
Exception raised when the connection is closed during the response.
Builder for ResponseCodeElement.
Method annotation for a response filter.
 
 
 
 
 
AOP Advice that can be applied to any method.
An event triggered on each retry.
Generalization of ApplicationEventListener for RetryEvent.
An exception thrown if there is something at miss with the Retry system.
An interface allows to provide custom condition for Retryable and CircuitBreaker.
An interface that encapsulates the current state of a Retryable operation.
The retry state builder.
Models a return type of an Executable method in Micronaut.
Represents a Route definition constructed by a RouteBuilder.
An interface for classes capable of building HTTP routing information.
A URI naming strategy is used to dictate the default name to use when building a URI for a class.
Allows defining a condition for this route to match using an expression.
Returns data for a given route to be used for the RoutesEndpoint.
Used to respond with route information used for the RoutesEndpoint.
A class responsible for executing routes.
Common information shared between route and route match.
A Route that is executable.
A filter responsible for filtering route matches.
 
Core Router interface that allows discovery of a route given an HTTP method and URI.
Exposes an Endpoint to display application routes.
Routes versioning configuration.
The result of route validation.
Describes a rule to validate a route.
Visits methods annotated with HttpMethodMapping and validates the parameters are consistent with the URI.
Implementation of RouteMatchFilter responsible for filtering route matches on Version.
An exception that occurs when building routes.
Internal implementation of the ChannelInboundHandler for Micronaut.
Interface for classes that instrument Runnable instances.
Allow the construction for bean definitions programmatically that can be registered via BeanDefinitionRegistry at runtime.
A builder for constructing RuntimeBeanDefinition instances.
A transformer that remaps io.reactivex.rxjava3.annotations.Nullable to javax.annotation.Nullable.
Asserts that a cookie must not be sent with cross-origin requests, providing some protection against cross-site request forgery attacks (CSRF).
Converts a string to a SameSite.
An annotation for scheduling a re-occurring task.
A default executor service for scheduling adhoc tasks via ScheduledExecutorService.
Simple abstraction over ScheduledExecutorService.
A ExecutableMethodProcessor for the Scheduled annotation.
 
Repeatable annotation wrapper for Scheduled.
A meta annotation for a scoped proxy.
Counter part to Primary that allows reducing the priority of a given bean for the purposes of dependency injection.
Annotation that can be applied to arguments that should be included in the endpoint URI.
The Netty implementation of SslBuilder that generates an SslContext to create a server handler with SSL support via a generated self-signed certificate.
Utility class for comparing semantic versions.
An annotation that can be applied at the method level to indicate that return value of said method should be sent to given destination.
Annotation that can be applied to endpoint methods to control sensitivity at the method level.
A generic exception that occurs during serialization or deserialization.
A contract for providing a context path to a server.
Mark a bean as a filter for the HTTP server.
A non-blocking and thread-safe filter chain.
Represents phases of server filters.
Http request propagation.
The holder for the current HttpRequest that is bound to instrumented threads.
A reactive streams publisher that instruments an existing publisher ensuring execution is wrapped in a ServerRequestContext.
Event fired when the EmbeddedServer shuts down.
Interface that allows for different builder instances to be able to create the SSLContext supplied later to the micronaut http server.
The default SslConfiguration used for HTTP servers.
Event fired when the EmbeddedServer completes startup.
An exception thrown on server startup.
Exposes an Endpoint to stop the server.
An API for a Micronaut HTTP Server under test.
Provides a server to test.
Utility class to retrieve a ServerUnderTestProvider via a Service Loader.
Annotation declared on the server to indicate the class handles web socket frames.
A processor that exposes WebSocket URIs via the router.
A service that may or may not be present on the classpath.
Allows defining HTTP client configurations via the micronaut.http.services setting.
The default connection pool configuration.
The default connection pool configuration.
Creates HttpClient instances for each defined ServiceHttpClientConfiguration.
A HealthIndicator used to display available load balancer URLs.
Represents a remote service discovered by the underlying discovery implementation.
A builder for building ServiceInstance references.
Interface for generating IDs for ServiceInstance.
Interface for types that expose a list of ServiceInstance.
The default LoadBalancer factory for creating LoadBalancer instances from ServiceInstanceList instances.
 
Strategy interface for classes to contribute to ServiceInstance metadata when registering an instance with a discovery service.
An event fired when a service has completed starting and is ready to service requests.
A HealthIndicator that signals when the service is ready to service requests.
An event triggered when a ServiceInstance has shutdown and will no longer service requests.
Converter registrar for HTTP classes.
An event fired prior to starting shutdown sequence.
Simple Cookie implementation.
Simple CookieFactory implementation.
Simple Cookies implementation.
Simple MutableHttpHeaders implementation.
Simple implementation of MutableHttpParameters.
Simple MutableHttpRequest implementation.
Simple HttpRequestFactory implementation.
Simple HttpResponseFactory implementation.
 
Parser for building AST for single evaluated expression.
Annotation that can be used to describe that an API emits a single result even if the return type is a Publisher.
A Processor that only allows a single Subscriber
A Publisher that only allows a single Subscriber.
A Reactive streams Processor designed to be used within a single thread and manage back pressure state.
A Subscriber designed to be used by a single thread that buffers incoming data for the purposes of managing back pressure.
Back pressure state.
An extension of HttpContentCompressor that skips encoding if the content type is not compressible or if the content is too small.
Utility methods for dealing with sockets.
Variation of ServiceLoader that allows soft loading and conditional loading of META-INF/services classes.
Static optimizations for service loaders.
Service collector for loading services of the given type.
A ServiceDefinition implementation that uses a MethodHandles.Lookup object to find a public constructor.
Service loader that uses SoftServiceLoader.StaticDefinition.
A transformer that remaps edu.umd.cs.findbugs.annotations.Nullable to javax.annotation.Nullable.
A client for streaming Server Sent Event streams.
A factory to create Server Sent Event clients.
Interface for managing the construction and lifecycle of instances of reactive clients.
A class to build a key store and a trust store for use in adding SSL support to a server.
Configuration properties for SSL handling.
Configuration properties for SSL key.
Configuration properties for SSL key store.
Configuration properties for SSL trust store.
An exception thrown while configuring SSL.
An event fired once startup is complete.
A static mutable message source.
This class is a generic container for pre-computed data which can be injected at initialization time.
Interface for an optimization which will be injected via service loading.
Utility class for testing originating element generation.
Stores configuration for the loading of static resources.
Resolves resources from a set of resource loaders.
A factory for creating the default StaticResourceResolver.
 
A ServiceInstanceList using a static list of URLs.
Sets alternative HttpStatus response code when applied to a method and HttpStatus code is specified.
Represents a Route that matches a status.
Represents a RouteInfo that matches a status.
 
Interface for types that can be written to an OutputStream.
A special type for streaming an InputStream representing a file or resource.
Combines HttpMessage and Publisher into one message.
Combines HttpRequest and StreamedHttpMessage into one message.
Combines HttpResponse and StreamedHttpMessage into one message.
Body writer for StreamedFiles.
A base function executor for handling input and output as streams
ByteBody implementation that wraps a StreamedHttpRequest.
Represents a part of a MediaType.MULTIPART_FORM_DATA request.
Extended version of the HttpClient that supports streaming responses.
A factory to create Streaming HTTP clients.
Interface for managing the construction and lifecycle of instances of StreamingHttpClient clients.
 
Utility methods for working with streams.
An enum representing different conventions.
 
Fixed-size String->int map optimized for very fast read operations.
Expression AST node for string literal.
String switch writer.
Utility methods for Strings.
Expression AST node for binary '-' operator.
Handles list, map and array de-referencing.
Processes the type and its super classes.
Helper methods for dealing with Supplier.
Used as the return value of a route execution to send File instances to the client.
Body writer for SystemFiles.
Loads properties from system properties.
An exception handler interface for task related exceptions.
 
The names of common task schedulers.
Interface for Scheduling tasks.
Expression AST node for ternary expressions.
Annotation processor for test generation.
Defines a HTTP Server Test Scenario.
Test Scenario Builder.
A codec that handles MediaType.TEXT_PLAIN.
Body handler for content type "text/plain".
A MediaTypeCodec that will encode Event objects in order to support Server Sent Events.
Enables access to 'this' in non-static contexts.
Exposes an Endpoint to display application threads.
Responsible for converting the standard Java ThreadInfo class into another object for serialization.
A CustomScope that stores objects in thread local storage.
Special version of PropagatedContextElement that is thread-aware and can update the thread context on the initial propagation entry and restore it on the propagation exist.
Enum the controls the ability to select threads in a Micronaut application.
Represents a function that accepts one argument and produces a result.
Represents a supplier of results.
Registers data time converters.
An interface for components or configurations that can be toggled on or off.
Parsed token with value and type.
Tokenizer for parsing evaluated expressions.
List of supported token types.
Annotation that can be applied to method to signify the method receives a HttpMethod.TRACE.
A JsonGenerator that returns tokens as a JsonNode.
A Condition that simply returns true.
 
 
Allows restricting injection by type.
Implementation of Type qualifier.
An ArgumentBinder that is resolved based on the argument type.
A Qualifier that qualifies beans by generic type arguments.
Common conventions for types
A type converter for converting from one type to another.
An interface for classes that register type conversions with the ConversionService.
A typed AnnotationMapper operates against a concrete annotation type.
A typed AnnotationTransformer operates against a concrete annotation type.
A ClientArgumentRequestBinder that is resolved based on the argument type.
An element that has an underlying type.
Set of constants and utility methods for working with type descriptors while compiling evaluated expressions.
A TypeArgumentBinder that binds from an HttpRequest.
A subscriber that is aware of the target type.
Provides a hook into the compilation process to allow user defined functionality to be created at compile time.
Implementors of the TypeElementVisitor interface should specify what kind of visitor it is.
The annotation processed used to execute type element visitors.
The type hint annotation is a general annotation that can be used on interfaces to provide additional information about types used at runtime.
The access type.
Expression node for type identifier.
Provides information about a type at runtime.
Interface that implementors can hook into to control the logic of methods like TypeInformation.isReactive().
An interface for types that hold and can resolve type variables.
Abstract expression node for unary operators.
An exception thrown when Introduction advise cannot be implemented.
Marker interface for unmatched request argument binder.
A variation of BeanIntrospection that includes UnsafeBeanInstantiationIntrospection.instantiateUnsafe(Object...) allowing to skip instantiation validation.
Unsafe bean property interface adds read/write methods which don't validate the input/output.
A variation of Executable that exposes invoke method without arguments validation.
A variation of ExecutionHandle that invokes without arguments validation.
An exception thrown when an Argument could not be satisfied by a ExecutableBinder.
Handles exception of type UnsatisfiedArgumentException.
An exception thrown when the an Body to a Route cannot be satisfied.
An exception thrown when the an CookieValue to a Route cannot be satisfied.
An exception thrown when the an Header to a Route cannot be satisfied.
An exception thrown when the an Part to a Route cannot be satisfied.
An exception thrown when the an PathVariable to a Route cannot be satisfied.
An exception thrown when the an QueryValue to a Route cannot be satisfied.
An exception thrown when the an RequestAttribute to a Route cannot be satisfied.
An exception thrown when the an Argument to a Route cannot be satisfied.
Handles exceptions of type UnsatisfiedRouteException.
Helper class for building URIs and handle encoding correctly.
Meta annotation for the mapped URI whether at the controller or action level.
A URI matcher is capable of matching a URI and producing a UriMatchInfo.
The result of a call to UriMatcher.match(java.net.URI).
Extends UriTemplate and adds the ability to match a URI to a given template using the UriMatcher.match(java.net.URI) method.
The default UriMatchInfo implementation.
Extended version of UriTemplate.UriTemplateParser that builds a regular expression to match a path.
Represents a variable in a URI template.
Represents a Route that matches a URI.
Represents a Route that matches a URI.
A RouteMatch that matches a URI and HttpMethod.
Thrown when the URI syntax is correct.
Handles exception of type URISyntaxException.
A Fast Implementation of URI Template specification.
Represents an expandable path segment.
An URI template parser.
A UriMatchTemplate that allows specifying types for the URI variables.
A typed uri match templated parser.
A marker annotation indicating that a method is used by generated code and should not be modified or removed otherwise a binary compatibility problem will be introduced.
Allows configuration ExecutorService instances that are made available as beans.
A bean definition that is validated with jakarta.validation.
Allows configuration injection from the environment or bean context on a per property, field, method/constructor parameter basis.
An exception that occurs related to configuration.
An interface for any type that is able to resolve and convert values.
Annotation used to express the version of a component or method.
Configuration to decorate Router with version matching logic.
An AnnotatedClientRequestBinder implementation for Version.
Resolves a version from a given object.
A marker for RouteMatchFilters related with Versioning.
 
Utility methods for versioning.
Veto the processing of the element.
Allows supplying configuration to the VisitorContext.
Provides a way for TypeElementVisitor classes to log messages during compilation and fail compilation.
Internal common helper functions to share among VisitorContext implementations.
A type that can be used to represent JSON errors that returns a content type of Vnd.Error.
The watch event type.
A factory that creates the default watch service.
Wrapper around a WebSocket instance that enables the retrieval of the appropriate methods.
Registry for WebSocket beans.
Defines WebSocket methods to broadcast messages.
Interface that provides a way to connect a client over WebSocket.
Exceptions specific to the WebSocket client.
A factory to create WebSocket clients.
Interface for managing the construction and lifecycle of instances of reactive WebSocketClient clients.
Stereotype meta-annotation declared on both ServerWebSocket and ClientWebSocket.
Parent class for all events emitted by the WebSocket server.
General parent exception for all WebSocket related exceptions.
Combines HttpResponse and Processor into one message.
Stereotype meta-annotation applied to all WebSocket related annotations such as OnOpen, OnMessage etc.
Encapsulate functionality to encode WebSocket messages.
An event fired after a WebSocket message has been processed.
Special message class that can be accepted by a @OnMessage method to listen to WebSocket pongs.
Represents an open WebSocket connection.
Interface used by ClientWebSocket to gain access to the underlying WebSocketSession.
Fired when a WebSocketSession is closed on the server.
Exceptions related to WebSocketSession interaction.
Fired when a WebSocketSession is opened on the Server.
Defines a ChannelGroup repository to handle WebSockets.
Holder object used to bind WebSocket state.
Interface for binders that bind from WebSocketState.
Handles binding WebSocket arguments from WebSocketState.
Creates the inbound handler for websocket upgrade requests.
Enum representing the different WebSocket versions.
A TypeElementVisitor that validates WebSocket implementations at compile time.
A class that can determine the weight of a value.
A common set of Weigher and EntryWeigher implementations.
Represents a wildcard, for example List<?>.
The element annotation metadata for wildcard element.
An interface for classes to implement that are capable of writing themselves to a Writer
Body writer for Writables.
A method designed to annotate an Endpoint write operation.
A processor that processes references to Write operations Endpoint instances.
Loads properties from a YML file.