# jetleaf library

## Classes

AbsolutePathValidator
  Validates that a URI contains an absolute path (starting with '/').
AbstractApplicationContext
  The base implementation of a configurable Jetleaf Application Context.
AbstractAutowirePodFactory
  Abstract base class for pod factories that support autowiring capabilities.
AbstractEnvironment
  Base class for creating environment implementations in JetLeaf.
AbstractPodDefinition
  An abstract base class for pod definitions that extends PodDefinition.
AbstractPodFactory
  Abstract base implementation of PodFactory that provides core functionality for pod creation, management, and lifecycle handling in the Jetleaf framework.
AbstractPodProviderFactory
  Retrieves the PodProvider backing a pod.
AliasRegistry
  An abstract interface for managing name aliases in a registry system.
AliasRegistryAware
  Contract for objects that support alias registration.
AllowedDomainsValidator
  Validates that a URI's host matches one of the allowed domains.
Annotation
  Provides reflective access to annotations applied to declarations.
AnnotationAwareOrderComparator
  A Jetleaf-provided OrderComparator implementation that determines ordering based on the presence of the `@Order` annotation or the Ordered interface.
AnnotationConfigApplicationContext
  ApplicationContext implementation that supports annotation-based configuration.
AnnotationConfigRegistry
  Annotation-Based Configuration Registry
AnnotationDeclaration
  Represents an annotation that has been applied to a class, method, field, parameter, or other Dart declarations at runtime.
AnnotationFieldDeclaration
  Represents a field of an annotation.
ApplicationArguments
  Defines the contract for accessing and parsing command-line arguments passed to an application.
ApplicationContext
  The central interface for a JetLeaf application context.
ApplicationContextAware
  🫘 Interface for components that need access to the ApplicationContext.
ApplicationContextEvent
  A base class for all events that are published within the context of an ApplicationContext.
ApplicationContextInitializer<T extends ConfigurableApplicationContext>
  Strategy interface for initializing an ApplicationContext before it is refreshed.
ApplicationEvent
  A base class for application-specific events within the JetLeaf framework.
ApplicationEventBus
  Defines the contract for an event multicaster that manages the registration, removal, and dispatching of `ApplicationEvent`s to `ApplicationListener`s.
ApplicationEventBusAware
  🫘 Interface for components that need access to the ApplicationEventBus.
ApplicationEventListener<E extends ApplicationEvent>
  A listener for a specific type of ApplicationEvent.
ApplicationModule
  An interface in Jetleaf that defines a configurable application module.
ApplicationStartup
  Instruments the application startup phase using StartupSteps.
ApplicationStartupAware
  Defines a contract for components that are aware of and can interact with an ApplicationStartup strategy.
ArgumentValue
  Holder for a constructor argument value, including its optional type and name metadata.
ArgumentValueHolder
  Argument Value Holder
ArrayList<E>
  A resizable array implementation similar to Java's ArrayList.
Asset
  🍃 JetLeaf Framework - Represents a non-Dart static resource (e.g., HTML, CSS, images).
AssetImplementation
  A concrete, immutable implementation of the Asset interface.
AssetPathResource
  Represents a resource that can be loaded from a path-based asset.
AssetResource
  An abstract representation of a resource that wraps either:
AutoCloseable
  An object that may hold resources (such as file or socket handles) until it is closed.
AutoConfiguration
  Declares a class as a source of automatic configuration.
AutowireCandidateDescriptor
  Describes whether a component is eligible for autowiring.
Autowired
  Autowired annotation for dependency injection
AutowirePodFactory
  Extends PodFactory with automatic dependency injection capabilities.
BaseStream<T, S extends BaseStream<T, S>>
  Base interface for streams, which are sequences of elements supporting sequential and parallel aggregate operations.
BigDecimal
  A wrapper class for precise decimal arithmetic.
BigInteger
  A wrapper class for arbitrary precision integers.
Boolean
  A wrapper class for bool that provides Java-like functionality and methods.
BootstrapContext
  A context used during JetLeaf's bootstrapping phase for accessing and managing lazily-created instances by their reflected Class types.
BootstrapInstanceSupplier<T>
  A supplier that can create instances based on a BootstrapContext, with optional scoping support.
BootstrapRegistry
  A registry interface for bootstrapping components during early phases of application startup.
BootstrapRegistryInitializer
  Strategy interface used to programmatically register bootstrap instances into a BootstrapRegistry before the application context is refreshed.
BufferedInputStream
  A BufferedInputStream adds functionality to another input stream-namely, the ability to buffer the input and to support the mark and reset methods.
BufferedOutputStream
  The class implements a buffered output stream.
BufferedReader
  Reads text from a character-input stream, buffering characters so as to provide for the efficient reading of characters, arrays, and lines.
BufferedWriter
  Writes text to a character-output stream, buffering characters to provide efficient writing of characters, arrays, and strings.
BulkChange
  Represents multiple observable events grouped together.
Byte
  A comprehensive wrapper class for byte operations, supporting both single bytes and byte collections.
ByteArray
  A wrapper for byte arrays similar to Java's byte[] with utility methods.
ByteArrayInputStream
  A byte-based input stream that reads from a Uint8List buffer.
ByteArrayOutputStream
  An OutputStream that writes to a growable internal byte buffer.
ByteStream
  A stream of bytes similar to Java's InputStream/OutputStream.
Character
  A wrapper class for single characters that provides Java-like functionality.
Class<T>
  Provides reflective access to Dart class types and their metadata.
ClassDeclaration
  Represents a reflected Dart class and all of its metadata, including fields, methods, constructors, superclasses, mixins, interfaces, and declaration-level modifiers (abstract, sealed, etc.).
ClassLoader
  An abstract class loader that manages the loading and caching of class metadata.
ClassLoaderStats
  Statistics and metrics for ClassLoader cache performance monitoring.
ClassPathResource
  Provides access to resources, classes, methods, and fields located in a package's classpath.
ClassType<T>
  The `ClassType` class in Jetleaf represents a reference to a Dart class, optionally including metadata such as package, protection domain, or type declaration.
ClassUtils
  A utility class that provides static methods for working with class hierarchies and type relationships in Dart's reflection system.
Cleanup
  Marks a method to be invoked after a pod is destroyed.
Closeable
  An object that may hold resources until it is closed.
Collector<T, A, R>
  A mutable reduction operation that accumulates input elements into a mutable result container, optionally transforming the accumulated result into a final representation after all input elements have been processed.
Collectors
  Implementations of Collector that implement various useful reduction operations, such as accumulating elements into collections, summarizing elements according to various criteria, etc.
Comparator<T>
  An abstract class that imposes a total ordering on a collection of objects of type `T`.
Component
  Component annotation for generic Jet components
ComponentScan
  Annotation for Jetleaf component scanning.
ComponentScanFilter
  Represents a filter definition for component scanning.
Conditional
  The `Conditional` annotation in Jetleaf allows developers to specify conditions that must be satisfied for a class or method to be processed by the framework.
ConditionalConverter
  A contract for a converter that only matches under certain conditions.
ConditionalOnAsset
  The `ConditionalOnAsset` annotation in Jetleaf allows developers to conditionally process a class or method based on the presence of an asset.
ConditionalOnClass
  The `ConditionalOnClass` annotation in Jetleaf allows developers to conditionally process a class or method only when certain classes are present in the runtime classpath.
ConditionalOnDart
  The `ConditionalOnDart` annotation in Jetleaf allows developers to conditionally process a class or method based on the Dart SDK version.
ConditionalOnExpression
  The `ConditionalOnExpression` annotation in Jetleaf allows developers to conditionally process a class or method based on a runtime expression.
ConditionalOnMissingClass
  The `ConditionalOnMissingClass` annotation in Jetleaf allows developers to conditionally process a class or method only when certain classes are absent from the runtime classpath.
ConditionalOnMissingPod
  The `ConditionalOnMissingPod` annotation in Jetleaf allows developers to conditionally process a class or method only when certain pods are not present in the application context.
ConditionalOnPod
  The `ConditionalOnPod` annotation in Jetleaf allows developers to conditionally process classes or methods based on the presence of specific pods in the application context.
ConditionalOnProfile
  Marks a class or method to be included only when specific profiles are active.
ConditionalOnProperty
  Marks a class or method as conditional based on the presence and value of configuration properties.
ConfigurableApplicationContext
  A specialized ApplicationContext that allows for full configuration and lifecycle management.
ConfigurableBootstrapContext
  A configurable bootstrap context that acts as both a BootstrapRegistry and a BootstrapContext.
ConfigurableConversionService
  A configurable conversion service that allows dynamic registration of converters.
ConfigurableEnvironment
  A configurable extension of the Environment interface that allows mutation of environment internals such as active profiles and property sources.
ConfigurableListablePodFactory
  The most comprehensive pod factory interface combining listing and configuration capabilities.
ConfigurablePodFactory
  A comprehensive pod factory interface with configuration capabilities.
ConfigurableRuntimeProvider
  A mutable context used to collect and assemble metadata during the framework’s initialization or AOT compilation phase.
Configuration
  Configuration annotation for configuration classes
ConsolePrintStream
  A concrete implementation of PrintStream that writes to the console using stdout.
Constant
  Constant class containing predefined constants used across the application.
Constructor
  Provides reflective access to class constructor metadata and instantiation.
ConstructorArgumentValues
  Holder for constructor argument values used when instantiating a pod.
ConstructorDeclaration
  Represents a constructor of a Dart class, including its parameters, modifiers (`const`, `factory`), and the ability to create new instances.
ContextClosedEvent
  Event published when an ApplicationContext is closed.
ContextFailedEvent
  Event published when the ApplicationContext fails to start or refresh.
ContextReadyEvent
  Event published when the ApplicationContext is ready.
ContextRefreshedEvent
  Event published when the ApplicationContext is refreshed or initialized.
ContextRestartedEvent
  Event published when the ApplicationContext is restarted.
ContextStartedEvent
  Event published when the ApplicationContext is started or restarted.
ContextStoppedEvent
  Event published when the ApplicationContext is explicitly stopped.
Controller
  Controller annotation for Jet View controllers
ConversionService
  A strategy interface for type conversion.
ConversionServiceAware
  🫘 Interface for components that need access to a ConversionService.
ConversionServiceConverter<S, T>
  A Converter that delegates to a ConversionService for converting values.
ConversionServiceFactory
  Utility class for registering a set of converters with a ConverterRegistry.
ConversionUtils
  Utility class containing common operations used by conversion infrastructure.
Converter<S, T>
  A generic interface for converting an input of type `S` into an output of type `T`.
ConverterFactory<S, R>
  A factory for creating Converter instances that convert from a source type `S` to a target type `T`, where `T` is a subtype of `R`.
ConverterRegistry
  A registry of converters and converter factories used to perform type conversions at runtime.
ConvertiblePair
  Represents a pair of source and target types for type conversion.
ConvertibleValue
  Abstraction for holding a raw value and its converted state.
ConvertingComparator<S, T>
  A comparator that compares source values of type `S` by first converting them to another type `T` using a Converter, then applying a Comparator on `T`.
Currency
  Abstract base class for currency operations following ISO 4217 standards.
Declaration
  Represents any top-level or member declaration in Dart code, such as a class, method, field, enum, typedef, etc., and exposes its metadata for reflection.
DefaultApplicationArguments
  Default implementation of ApplicationArguments that wraps command-line arguments and exposes them via a `PropertySource`-based backing system.
DefaultApplicationHook
  Default implementation of `ApplicationHook` providing basic hook functionality.
DefaultApplicationStartup
  A no-op implementation of ApplicationStartup that always returns a singleton DefaultStartupStep for any startup operation.
DefaultAssetPathResource
  Default implementation of AssetPathResource that resolves assets from the runtime environment using a path or filename.
DefaultClassLoader
  The default system implementation of ClassLoader with comprehensive caching.
DefaultClassPathResource
  Default implementation of ClassPathResource that resolves and provides access to classes, methods, fields, and packages from the Dart runtime.
DefaultConversionService
  A specialization of SimpleConversionService configured by default with converters appropriate for most environments.
DefaultListablePodFactory
  Default implementation of ConfigurableListablePodFactory that provides comprehensive pod management capabilities in the Jetleaf framework.
DefaultObjectProvider<T>
  Default implementation of ObjectProvider in Jetleaf.
DefaultStartupStep
  A no-op implementation of StartupStep used by DefaultApplicationStartup.
DefaultStartupStepTags
  A no-op, empty tag collection returned by DefaultStartupStep.
DependencyDescriptor
  Describes a dependency required by a component or pod.
DependencyDesign
  Describes a dependency required by a component or pod.
DependsOn
  A Jetleaf annotation that declares explicit dependencies between pods.
Description
  Provides a human-readable description of a class or method.
DesignDescriptor
  Describes the design role configuration of a component.
PodDestructionProcessor
  An abstract class in Jetleaf that provides lifecycle hooks for Pod destruction.
DisposablePod
  Interface to be implemented by pods that need to release resources or perform cleanup when being removed from the container or shut down.
Double
  A wrapper class for double that provides Java-like functionality and methods.
DoubleStream
  A sequence of primitive `double`-valued elements supporting sequential and parallel aggregate operations.
EnableAutoConfiguration
  Core framework annotations for Jet
EntityDeclaration
  An abstract base class that defines a reflective entity in the system, providing a common identifier useful for debugging, logging, or inspection.
EntryApplicationAware
  🚀 Interface for components that need access to the entry application class.
EnumDeclaration
  Represents a reflected Dart `enum` type, providing access to its enum entry names, metadata, and declared members (fields, methods).
EnumFieldDeclaration
  Abstract base class representing a field (value) within an enum declaration.
Env<T>
  A generic configuration property accessor for environment variables.
Environment
  Environment Contract
EnvironmentAware
  🫘 Interface for components that can be configured with an Environment.
EventListener
  Annotation to mark a method that should run when the application is listening to a specific type of ApplicationEvent.
EventObject
  A base class for all framework-level events.
EventType<T extends ApplicationEvent>
  🫘 Represents a typed application event associated with a specific package.
Executable
  Abstract base class for executable elements (methods, constructors, functions).
ExecutableHolder
  Executable Holder
ExecutableStrategy
  Executable Strategy
ExitCodeEvent
  An ApplicationEvent that signals the application should exit with a specific exit code.
ExitCodeExceptionHandler
  A strategy interface for mapping a specific Exception to a process exit code.
ExitCodeGenerator
  Strategy interface for determining the exit code returned from a JetLeaf application or a process.
ExitCodeGenerators
  A container and manager for multiple ExitCodeGenerator instances.
ExtensionDeclaration
  Represents a Dart `extension` declaration at runtime.
FactoryMethodDesign
  Describes a factory method used to create a pod (component).
Field
  Provides reflective access to class field metadata and value manipulation.
FieldAccess
  Provides reflective access to fields of a class.
FieldDeclaration
  Represents a field (variable) declared within a Dart class, extension, enum, or mixin.
FileInputStream
  A FileInputStream obtains input bytes from a file in a file system.
FileOutputStream
  A file output stream is an output stream for writing data to a File or to a file descriptor.
FileReader
  Convenience class for reading character files.
FileWriter
  Convenience class for writing character files.
Float
  A wrapper class for single-precision floating point numbers.
Flushable
  An object that can be flushed.
Generic
  A reflectable annotation that marks generic classes for type reflection.
GenericApplicationContext
  Generic ApplicationContext implementation that holds a single internal DefaultListablePodFactory instance and does not assume a specific pod definition format.
GenericNullConverter
  A contract for a converter that only matches under certain conditions.
GenericStream<T>
  A sequence of elements supporting sequential and parallel aggregate operations.
GenericTypeParser
  Provides utilities for parsing and analyzing generic type strings in Dart.
GenericTypeParsingResult
  Represents the parsed structure of a generic type.
GlobalEnvironment
  A concrete implementation of AbstractEnvironment that represents the default runtime environment for most applications.
HashMap<K, V>
  A custom implementation of a hash map that implements the `Map<K, V>` interface.
HashSet<E>
  A custom implementation of a hash set that implements the `Set<E>` interface.
HierarchicalPodFactory
  Extends PodFactory with hierarchical capabilities for parent-child relationships.
HostValidator
  Validates that a URI contains a hostname component.
HttpUrlConnection
  A concrete implementation of UrlConnection for HTTP and HTTPS protocols.
Import
  The `Import` annotation in Jetleaf is used to import other configuration classes.
ImportClass
  🫘 Represents an import entry with optional qualification metadata.
ImportSelector
  🫘 A strategy interface for selecting which imports should be applied.
InitializingPod
  Interface to be implemented by pods that require initialization logic after their properties have been set by the container.
InputStream
  This abstract class is the superclass of all classes representing an input stream of bytes.
InputStreamSource
  A simple interface for objects that provide an InputStream.
Instance
  A utility class for type checking, similar to Java's `instanceof`. It also provides additional methods for type checking.
InstanceArgument
PodInstantiationProcessor
  An abstract class in Jetleaf that builds upon `AwarePodProcessor`.
Integer
  A wrapper class for int that provides Java-like functionality and methods.
IntStream
  A sequence of primitive `int`-valued elements supporting sequential and parallel aggregate operations.
JetApplication
  Main entry point for JetLeaf framework applications.
JetLeafApplication
  A meta-annotation in Jetleaf used to bootstrap and configure the root application class.
KeepAlive
  A lifecycle-aware component that keeps the Dart VM alive as long as the ApplicationContext is running.
KeyValueOf<K, V>
  KeyValueOf Annotation
Lazy
  Indicates that a pod should be lazily initialized.
LibraryDeclaration
  Represents a Dart library, providing access to its URI, the containing package, and all top-level declarations inside it.
Lifecycle
  A common interface defining methods for start/stop lifecycle control.
LifecycleDesign
  Describes lifecycle behavior of a component, such as initialization and destruction methods.
LinkDeclaration
  Abstract base class for type references in reflection systems.
LinkedList<E>
  A custom implementation of a doubly linked list that implements the standard `List<E>` interface.
LinkedQueue<E>
  A queue implementation using a linked list structure, mimicking Java's LinkedList as Queue.
LinkedStack<E>
  A stack implementation using a linked list structure, mimicking Java's LinkedList as Stack.
ListableConverterRegistry
  A ConverterRegistry that also provides access to registered UriValidator instances.
ListablePodDefinitionRegistry
  Interface for registries that provides additional functionality for listing and enumeration.
ListablePodFactory
  Extends PodFactory with capabilities to list and query pods.
ListChange<T>
  Represents a change in a `List`.
LocalDate
  Represents a calendar date without time or timezone.
LocalDateTime
  A date-time object without a timezone, composed of a LocalDate and LocalTime.
Locale
  A representation of a locale, consisting of a language code and optional country and variant codes.
LocalThread<T>
  A Dart equivalent of Java's `ThreadLocal`, scoped to the current Isolate.
LocalThreadStorageBucket<T>
  A mutable storage container for a LocalThread value, bound to a specific Isolate.
LocalTime
  A value object representing a time of day without any date or timezone information.
Long
  A wrapper class for large integers that provides Java-like functionality.
MapChange<K, V>
  Represents a change in a `Map`.
Member
  Abstract base class representing a member of a class that extends Executable.
MemberDeclaration
  Abstract base class representing a member of a class that extends Executable.
Mergeable
  Interface for objects that can merge with other objects of the same type.
MessageSourceAware
  🫘 Interface for components that need access to a `MessageSource`.
Method
  Provides reflective access to class method metadata and invocation capabilities.
MethodDeclaration
  Represents a method declaration in a Dart class, extension, mixin, or top-level scope.
MixinDeclaration
  Represents a reflected Dart `mixin` declaration, providing access to its members, type constraints, and metadata.
MutablePropertyValues
  Mutable implementation of PropertyValues interface.
NamedLocalThread<T>
  A specialized LocalThread that includes a descriptive name for better debugging and identification.
NetworkInputStream
  An InputStream implementation that reads bytes from a Dart Stream<List<int>>.
NetworkOutputStream
  An OutputStream implementation that writes bytes to a Dart `HttpClientRequest`.
NoCredentialsValidator
  Validates that a URI doesn't contain user credentials (username/password).
NoIpAddressValidator
  Validates that a URI uses a domain name rather than a raw IP address.
NoSpacesValidator
  Validates that a URI string doesn't contain any spaces.
NullablePod
  A special marker pod instance that represents a nullable or absent pod value.
ObjectFactory<T>
  A generic factory interface for producing instances of a given type `T`.
ObjectHolder<T>
  A generic container that holds an object along with optional metadata such as its package name and qualified name.
ObjectProvider<T>
  A flexible, functional-style provider interface for retrieving and interacting with pods or objects of a particular type.
Obs<T>
  A reactive wrapper for values, lists, or maps.
ObsEvent
  A base class representing an event in an observable system.
OnApplicationFailed
  Annotation to mark a method that should run when the application fails to start or refresh.
OnApplicationReady
  Annotation to mark a method that should run when the application is fully ready to serve requests.
OnApplicationStarted
  Annotation to mark a method that should run when the application has started, meaning the context is refreshed but the app is not yet fully ready.
OnApplicationStarting
  Annotation to mark a method that should run when the application is starting, before the context refresh occurs.
OnApplicationStopped
  Annotation to mark a method that should run when the application has fully stopped.
OnApplicationStopping
  Annotation to mark a method that should run when the application is stopping.
OnContextLoaded
  Annotation to mark a method that should run when the application context has been loaded, but before it is fully refreshed.
OnContextPrepared
  Annotation to mark a method that should run when the application context has been prepared.
OnEnvironmentPrepared
  Annotation to mark a method that should run when the application environment has been prepared, but before the context is loaded.
Optional<T>
  A container object which may or may not contain a non-null value.
Order
  Specifies the order of precedence for a class when processed by the framework or runtime system.
OrderComparator
  A comparator that sorts objects based on the Ordered and PriorityOrdered interfaces.
Ordered
  A contract for objects that are assigned an order or precedence value.
OrderSourceProvider
  A strategy interface for providing an alternative source of order metadata for a given object.
OutputStream
  This abstract class is the superclass of all classes representing an output stream of bytes.
Package
  🍃 JetLeaf Framework - Represents a Dart package within the runtime context.
PackageIdentifier
  Represents an abstraction for identifying the package that an object, resource, or service belongs to.
PackageNames
  A central collection of constant package name identifiers used throughout the Jetleaf framework.
PairedConditionalConverter
  A bridge interface combining PairedConverter and ConditionalConverter.
PairedConverter
  A general-purpose converter that can convert between multiple source–target type pairs.
Parameter
  Provides reflective access to method/constructor parameter metadata.
ParameterDeclaration
  Represents a parameter in a constructor or method, with metadata about its name, type, position (named or positional), and default value.
ParameterizedTypeReference<T>
  A runtime type reference for capturing and working with parameterized/generic types.
PermissionManager
  Abstract interface for elements that can have protection domains.
Phased
  Interface for objects that may participate in a phased process such as lifecycle management.
Pod
  Marks a method as a pod provider, enabling it to participate in the dependency injection (DI) lifecycle of the application.
PodProcessor
  The `AwarePodProcessor` is an abstract interface class provided by Jetleaf.
PodDefinition
  Defines the blueprint of a pod (component) in the dependency injection system.
PodDefinitionRegistry
  Interface for registries that hold PodDefinition instances.
PodExpression<T>
  Pod Expression Contract
PodExpressionContext
  Context for evaluating expressions in a pod environment.
PodExpressionResolver
  Strategy interface for resolving pod definition values and expressions.
PodFactory
  The core factory interface for managing and retrieving pods (components) in Jetleaf.
PodFactoryAware
  🫘 Interface for components that need access to the PodFactory.
PodFactoryPostProcessor
  Factory hook that allows for custom modification of an application context's pod definitions, adapting the pod property values of the context's underlying pod factory.
PodNameAware
  🫘 Interface for components that need to know their assigned pod name.
PodNameGenerator
  Strategy interface for generating pod names for PodDefinitions.
PodProvider<T>
  Interface for objects that are themselves factories for other objects.
PodRegistrar
  A contract in Jetleaf for components that can register pods into the application’s dependency container.
PodRegistry
  A contract in Jetleaf that provides methods for managing pods in the container.
PodScope
  Interface for pod scopes that manage object lifecycle and contextual storage.
PostConstruct
  Marks a method to be invoked after a pod has been fully constructed and its dependencies injected, but before it is made available for use in the context.
PreConstruct
  Marks a method to be invoked before a pod has been fully constructed and its dependencies injected, but before it is made available for use in the context.
PreDestroy
  Marks a method to be invoked before a pod is destroyed.
Primary
  Primary annotation for marking a primary pod
PrintStream
  An abstract interface representing a stream for formatted text output.
PriorityOrdered
  A special marker interface for Ordered objects that should be given priority over other Ordered objects during sorting or processing.
Profile
  Profile annotation for profile-specific pods
Profiles
  A profile predicate used by Environment to determine if given profile expressions match the active/default profiles.
Properties
  The Properties interface provides a clean, method-based API for querying the runtime environment. Unlike direct property access, all system state is exposed via methods to enforce immutability and ensure consistent naming conventions.
PropertyValue
  Represents a property with a `_name` and its associated `_value`.
PropertyValues
  Interface for accessing a collection of PropertyValue objects.
ProtectionDomain
  The protection domain used for type conversion.
QualifiedName
  Represents an object that can provide a fully qualified name.
Qualifier
  A Jetleaf annotation used to disambiguate injection targets when multiple candidate pods of the same type exist.
QueryParamValidator
  Validates that a URI contains all required query parameters.
Queue<E>
  A first-in-first-out (FIFO) queue interface implementation, mimicking Java's Queue.
Reader
  Abstract class for reading character streams.
RecordDeclaration
  Represents a reflected Dart record type.
RecordFieldDeclaration
  A representation of an individual field within a Dart record type in the JetLeaf reflection system.
ReflectableAnnotation
  Represents an annotation that has been applied to a class, method, field, parameter, or other Dart declarations at runtime.
RegexUtils
  A collection of commonly used regular expressions, provided as constants.
Repository
  Repository annotation for generic Jet repositories
RequiredAll
  An annotation used for dependency injection that automatically injects all eligible fields into a class.
ResolvableType
  A comprehensive type resolution system for Dart that provides advanced type introspection, generic type handling, and assignability checking capabilities.
Resolved
  An annotation used to mark classes for which AOT-compatible runtime resolvers should be generated.
ResourceDeclaration
  Abstract base class for declarations of external resources in reflection systems.
Role
  Declares the design role of a class or method within a Jetleaf application.
RootPodDefinition
  A concrete implementation of AbstractPodDefinition that serves as the default pod definition in the system.
Runnable
  A simple contract for objects that can be executed.
RuntimeHint
  A hint that defines how to interact with a specific type `Object` through reflection-like operations.
RuntimeHintDescriptor
  Abstract interface which provides all the RuntimeHints that are registered with JetLeaf's reflection system.
RuntimeHintProcessor
  An abstract interface that users can implement to configure the RuntimeHintDescriptor registry.
RuntimeMetadataProvider
  A contract for providing access to reflection metadata in JetLeaf.
RuntimeProvider
  Represents a runtime reflection context for a Dart application, providing access to libraries, packages, assets, and metadata.
RuntimeResolver
  An interface that portrays how any code is handled in JetLeaf's reflection system.
SchemeValidator
  Validates that a URI contains a scheme component (e.g., "https://").
Scope
  Annotation that specifies the scope of a pod within the JetLeaf container.
ScopeDesign
  Describes the scope configuration of a component.
ScopedObjectFactory<T>
  An ObjectFactory implementation that retrieves objects from a specific PodScope.
SecureSchemeValidator
  Validates that a URI uses a secure scheme (https or wss by default).
Service
  Service annotation for service layer components
Short
  A wrapper class for int representing a 16-bit signed integer.
SimpleAliasRegistry
  A thread-safe implementation of AliasRegistry using LocalThread storage.
SimpleConversionService
  A comprehensive type conversion service that handles conversion between different types.
SimpleObjectFactory<T>
  Default implementation of the ObjectFactory interface that uses a creator function.
SimplePodDefinitionRegistry
  A basic registry for managing pod definitions.
SimplePodNameGenerator
  Default implementation of the PodNameGenerator interface.
SingletonPodRegistry
  Interface for registries that hold singleton pod instances.
SmartInitializingSingleton
  Callback interface triggered at the end of the singleton pre-instantiation phase.
SmartLifecycle
  An extension of the Lifecycle interface for those objects that require to be started upon ApplicationContext refresh and/or shutdown in a particular order.
Source
  Abstract base class for all reflection metadata that can be annotated.
SourceDeclaration
  Represents any top-level or member declaration in Dart code, such as a class, method, field, enum, typedef, etc., and exposes its metadata for reflection.
Spec<T>
  A Jetleaf definition describing how a pod should be instantiated, configured, and managed inside the container.
SpecContext
  A context object in Jetleaf provided to suppliers and pod definitions for resolving dependencies at runtime.
Stack<E>
  A last-in-first-out (LIFO) stack implementation, mimicking Java's Stack.
StandardEntityDeclaration
  Concrete implementation of EntityDeclaration providing standard reflection metadata.
StandardEnumFieldDeclaration
  Concrete implementation of EnumFieldDeclaration representing an enum value.
StandardRuntimeProvider
  Default mutable implementation of ConfigurableRuntimeProvider.
StandardSourceDeclaration
  Concrete implementation of SourceDeclaration representing source-level declarations.
StandardStartupTracker
  Standard implementation of the {@macro startup} interface.
StandardSystemDetector
  Default implementation of SystemEnvironmentDetector for standard Dart environments.
StartupStep
  Step recording metrics about a particular phase or action happening during the ApplicationStartup.
StartupStepTag
  Attaches a static key/value `tag` to this step.
StartupStepTags
  Returns the complete list of StartupStepTags associated with this step.
StartupTracker
  Represents a startup lifecycle monitor for JetLeaf-based applications.
StreamBuilder<T>
  A mutable builder for a GenericStream.
StreamSupport
  Low-level utility methods for creating and manipulating streams.
StringBuilder
  A mutable sequence of characters similar to Java's StringBuilder.
StringReader
  A Reader implementation that reads characters from a String buffer.
StringValueResolver
  Interface for resolving string values to their actual values.
SuppliedNamedLocalThread<T>
  A NamedLocalThread that provides an initial value using a Supplier function.
SynchronizedLock
  A reentrant async lock for critical section execution.
SystemDetector
  Strategy interface for detecting and creating SystemEnvironment instances.
SystemPropertiesBuilder
  Builder for creating `_SystemProperties` instances using a fluent API.
TargetType<T>
  TargetType Annotation
Thread<T>
  Emulates Java's `Thread` class using Dart's `Isolate`.
ThreadMessage
  Wrapper message passed to the Isolate's entry point function.
ToStringOptions
  Configuration options for customizing `toString` output in JetLeaf objects.
TypeDeclaration
  Represents metadata information about any Dart type — including classes, enums, typedefs, generic types like `List<int>`, and even nullable types.
TypedefDeclaration
  Represents a reflected Dart `typedef`, which is a type alias for a function type, class type, or any other complex type.
TypeFilter
  Usage
TypeProvider
  Interface providing access to Type information with optional source context.
TypeVariableDeclaration
  Represents a reflected type variable, such as `T` in a generic class declaration like `class MyClass<T extends num>`.
UriTemplate
  A utility class for defining and working with URI templates that include path variables (e.g., `/users/{id}/orders/{orderId}`).
UriValidator
  An abstract validator for URI/URL validation.
Url
  Represents a Uniform Resource Locator (URL) and provides methods to parse, construct, and open connections to the referenced resource.
UrlConnection
  Represents a communication link between the application and a Url.
Uuid
  A powerful, secure implementation of Universally Unique Identifiers (UUIDs) following RFC 4122 specifications.
Value
  Value annotation for property injection
ValueChanged<T>
  Represents a change in a single observable value.
VariableResolver
  Strategy interface used to resolve type variables in generic contexts.
Version
  Represents a semantic version in Jetleaf with major, minor, and patch components.
VersionRange
  Represents a simple semantic version range in Jetleaf.
Writer
  Abstract class for writing to character streams.
ZonedDateTime
  Represents a date-time with timezone information.
ZoneId
  Represents a time zone identifier, abstracting the concept of region-based or offset-based zone IDs (e.g., 'UTC', 'America/New_York').

## Enums

ApplicationType
  Enumeration of types of applications that can be run in a JetLeaf environment.
AutowireMode
  Defines strategies for automatically wiring dependencies in a system.
DependencyCheck
  Defines the type of dependency validation to be performed when initializing a component or system.
DesignRole
  Defines the architectural role of a component within a system.
DomainPermission
  Enumeration of reflection-based permissions for secure access to class metadata, fields, methods, constructors, and annotations within a container or framework.
FilterType
  Enumeration of supported filter types for component scanning.
ListChangeType
  Represents the type of change that occurs in a `List`.
MapChangeType
  Represents the type of change that occurs in a `Map`.
ScopeType
  Defines the lifecycle scope of a component within a dependency injection container.
TypeKind
  Defines the kind of a reflected type within the JetLeaf reflection system.
TypeVariance
  Represents the variance annotations for generic type parameters in Dart.

## Mixins

ConfigurationPropertySource
  A mixin that provides access to a globally attached Environment.
EqualsAndHashCode
  Mixin-style contract for value-based equality, `hashCode`, and `toString`.
ToString
  A mixin that provides customizable toString implementation using the same properties defined in EqualsAndHashCode.equalizedProperties.

## Extensions

AssetExtension on Asset
  Extension methods for Asset objects.
BoolExtensions on bool
ClassExtension on Object
  Extension providing reflection capabilities to all Dart objects.
ClassHierarchyExtensions on ClassDeclaration
  Extensions for type hierarchy traversal
DateTimeExtensions on DateTime
DoubleExtensions on double
DurationExtension on Duration
DynamicExtensions on dynamic
ErrorExtensions on Error
  Extension on Error for printing full stack traces conveniently.
ExceptionExtensions on Exception
  Extension on Exception to provide utility methods such as printing stack traces.
IntExtensions on int
IterableExtension on Iterable<T>
ListExtensions on List<T>
MapExtensions on Map<K, V>
MethodOverrideExtensions on MethodDeclaration
  Extensions to support method override detection
NumExtensions on num
RuntimeExceptionExtensions on RuntimeException
  Extension on RuntimeException to support pretty stack trace printing.
SetUtils on Set<Object?>
  Utility extension methods for working with sets in Dart.
SortByPublic on Iterable<T>
  Extension providing sorting capabilities for collections of Declaration objects.
StackTraceExtensions on StackTrace
  Extension on StackTrace to print itself.
StdExtension on Stdout
  Extension to simulate Java's `System.out` and `System.err` utilities in Dart.
StringExtensions on String
SystemExtension on _System
  Extension on `InternalSystemContext` that provides access to system-level and environment-related properties similar to Java's `System.getProperties()` and `System.getenv()`.
TExtensions on T?
ThrowableExtensions on Throwable
  Extension on Throwable to support printing stack traces in a unified way.
ThrowingConsumerX on ThrowingConsumer<T>
  Extension methods for ThrowingConsumer providing safe execution.
ThrowingSupplierGet on ThrowingSupplier<T>
  A functional interface that supplies a value and may throw an exception.
TypeDeclarationExtension on TypeDeclaration
  Extension providing type casting and declaration resolution for TypeDeclaration.
TypeExtension on Type
UriExtension on Uri
  Extension on Dart's Uri class to convert it into a Url instance.

## Properties

isolateLocalValueStore → _IsolateLocalValueStore
  Singleton instance of the `_IsolateLocalValueStore`.
  final
MetaClassLoader → ClassLoader
  The default system implementation of ClassLoader with comprehensive caching.
  final
Runtime → _MetaRuntimeProvider
  A central, globally accessible proxy for runtime metadata in JetLeaf.
  final
System → _System
  Internal system facade for the JetLeaf framework.
  final

## Functions

synchronized<T>(Object monitor, T action()) → T
  Runs the given `action` in a critical section, ensuring only one execution at a time per `monitor` object.
synchronizedAsync<T>(Object monitor, FutureOr<T> action()) → FutureOr<T>
  Runs the given `action` in a critical section, ensuring only one execution at a time per `monitor` object.
tryWith<T extends AutoCloseable>(T resource, TryWithAction<T> action) → Future<void>
  Utility for automatically closing a resource after use.

## Typedefs

Accumulator<T, U> = U Function(U, T)
  A function used to accumulate values in reduction operations.
AssetResourceContentDetector = bool Function(Object source)
  A function signature for detecting whether a given source should be treated as content rather than a file path.
AssetResourceExtensionStrategy = String? Function(Object source)
  A function signature for determining the extension of an AssetResource.
Bool = bool
  An alias for the built-in `bool` type.
BoolCollection = List<Bool>
  A list of boolean values using the `Bool` alias.
BoolSet = Set<Bool>
  A set of unique boolean values using the `Bool` alias.
ConditionTester<T> = bool Function(T value)
  A typedef for a predicate function that tests a condition on a value of type `T`.
Consumer<T> = void Function(T value)
  A function that consumes a value of type `T` without returning anything.
DataMapper<T, U> = U Function(T value)
  A function that transforms a value from type `T` to type `U`.
DateTimeCollection = List<DateTime>
  A list of `DateTime` values.
DateTimeSet = Set<DateTime>
  A set of unique `DateTime` values.
DurationCollection = List<Duration>
  A list of `Duration` values.
DurationSet = Set<Duration>
  A set of unique `Duration` values.
ExceptionSupplier = Object Function()
  A function that returns an exception object to be thrown when needed.
GetValueCreator = Object? Function(Object instance, String name)
  Typedef for a function that gets the value of a field on an instance of type `Object`.
Int = int
  A shorthand alias for an integer value.
IntCollection = List<Int>
  A list of integers using the `Int` alias.
IntSet = Set<Int>
  A set of unique integers using the `Int` alias.
InvokeMethodCreator = Object? Function(Object instance, String method, List<Object?> args, Map<String, Object?> namedArgs)
  Typedef for a function that invokes a method on an instance of type `Object`.
JsonMap = Map<String, dynamic>
  A JSON-like structure represented as a `Map<String, dynamic>`.
JsonMapCollection = List<JsonMap>
  A list of JSON-like maps, useful for handling multiple entities.
JsonString = Map<String, String>
  A map of string keys and string values representing simple string-based JSON data.
NewInstanceCreator = Object Function(String name, List<Object?> args, Map<String, Object?> namedArgs)
  Typedef for a function that creates a new instance of type `Object`.
ObjectFactoryFunction<T> = FutureOr<ObjectHolder<T>> Function([List<ArgumentValue>? args])
  A function that creates an instance of type `T`.
PodDefinitionHolder = (String, PodDefinition, List<String>)
  Type definition for a pod definition holder tuple.
PodHolder = (Object, Class)
  A tuple representing a pod and its class.
Predicate<T> = Bool Function(T value)
  A function that takes a value of type `T` and returns a boolean.
SetValueCreator = void Function(Object instance, String name, Object? value)
  Typedef for a function that sets the value of a field on an instance of type `Object`.
StringCollection = List<String>
  A list of strings.
StringSet = Set<String>
  A set of unique strings.
Supplier<T> = T Function()
  A function that supplies a value of type `T`, typically lazily or on-demand.
ThrowingConsumer<T> = void Function(T value)
  A consumer function that can throw exceptions.
ThrowingSupplier<T> = T Function()
  A functional interface that supplies a value and may throw an exception.

## Exceptions / Errors

ClassNotFoundException
  A runtime exception in Jetleaf thrown when a requested class cannot be found by the runtime provider.
ComparatorException
  Exception thrown when a comparator is used with a type that is not comparable.
ConversionException
  Exception thrown when a type conversion fails in a ConversionService.
ConversionFailedException
  Exception thrown when an actual type conversion attempt fails.
ConverterNotFoundException
  Exception thrown when no suitable converter can be found for a given source and target type.
DartLoadingException
  Exception thrown when Dart file loading fails.
EndOfStreamException
  Exception thrown when the end of a stream is reached unexpectedly.
EnvironmentParsingException
  An Exception thrown when an error occurs during environment property parsing.
FatalPodException
  Base class for fatal pod-related exceptions that indicate unrecoverable errors.
IllegalArgumentException
  Thrown when a method is passed an illegal or inappropriate argument.
IllegalStateException
  Signals that a method has been invoked at an illegal or inappropriate time.
InvalidArgumentException
  Exception thrown when an invalid argument is provided.
InvalidFormatException
  Exception thrown when an invalid format is provided.
IOException
  Exception thrown when an I/O operation fails.
JsonParsingException
  An exception that occurs during JSON parsing.
LangException
  General exception for language related errors.
MalformedUrlException
MessageSourceException
  An exception that occurs when resolving messages from a `MessageSource`.
MissingRequiredEnvironmentException
  Exception thrown when a required environment variable is not found.
MissingRequiredPropertiesException
  Exception thrown when required properties are not found.
MultipleSourceException
  Exception thrown when multiple class definitions with the same name are found.
NestedCheckedException
  Abstract base class for checked exceptions that can wrap other exceptions.
NestedRuntimeException
  Abstract base class for runtime exceptions that can wrap other exceptions.
NetworkException
  Thrown to indicate an I/O error during network operations.
NoGuaranteeException
  Exception thrown when a guarantee is not met. Mostly used to behave like NoGuaranteeException
NoSuchElementException
  Thrown when an operation attempts to access an element that does not exist.
NoSuchPodDefinitionException
  Exception thrown when a `PodFactory` is asked for a pod instance by name, and no definition for that pod name exists.
NoUniquePodDefinitionException
  Exception thrown when multiple pod definitions are found for a given type in the application context.
PodCreationException
  Exception thrown when a pod cannot be created.
PodCreationNotAllowedException
  Exception thrown when a pod creation is not allowed in the current context.
PodCurrentlyInCreationException
  Exception thrown when a pod is currently in the process of being created.
PodDefinitionOverrideException
  Exception thrown when a pod definition is overridden.
PodDefinitionStoreException
  Exception thrown when a pod definition store error occurs.
PodDefinitionValidationException
  Exception thrown when a pod definition is invalid during validation.
PodException
  Base exception type for all pod-related errors in JetLeaf.
PodIsAbstractException
  Exception thrown when attempting to instantiate a pod that is marked as abstract.
PodIsNotAProviderException
  Exception thrown when a pod is expected to be a PodProvider but is not.
PodNotOfRequiredTypeException
  Exception thrown when a pod retrieved from the context is not of the expected type.
PodProviderNotInitializedException
  Exception thrown when attempting to use a PodProvider that hasn't been fully initialized.
ReentrantSynchronizedException
  Exception thrown when a synchronized block is reentered from the same zone.
RuntimeException
  Represents an unchecked runtime exception in JetLeaf.
ScopeNotActiveException
  Exception thrown when a pod is requested from a scope that is not active.
SecurityException
  Exception thrown when a security violation occurs.
StreamClosedException
  Exception thrown when an attempt is made to use a stream that has been closed.
ThreadInterruptedException
  Exception thrown when an Isolate (thread) is unexpectedly interrupted during execution.
ThreadSpawnException
  Exception thrown when an Isolate fails to start properly due to issues such as invalid entrypoint, unsupported data, or environment errors.
Throwable
  Base class for all throwable exceptions in JetLeaf.
TypeResolutionException
  Exception thrown when type lookup or resolution fails.
UnImplementedResolverException
  Exception thrown when an operation in the `ExecutableResolver` is not implemented or cannot be resolved at runtime.
UnsatisfiedDependencyException
  Exception thrown when a dependency is not satisfied for a pod.
UnsupportedOperationException
  Thrown to indicate that a requested operation is not supported.
UriPathMatchingException
  Exception thrown when a URI or route path fails to match a defined template in a path matcher.