@xeno-js/core 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,1971 @@
+import { IPipelineBehavior, IRequest, IExtendendService, IBaseAuthService, IServiceExtractor, HttpHeaders, Optional, ICache, ICacheKeyBuilder, IBaseMapper, AuthClaims, Identity, ICommand, IQuery, IConcurrencyService, IConfigurationService, ILoggerClient, IGateKeeper, IIdempotencyStore, ILogger, IMediator, IMiddleware, IStrategy, IPolicyRegistry, HttpMethod, RequestContext, IServiceResilience, Metadata, IFactory, ITransactionState, IUnitOfWork, IDisposable, IValidatorService, IIdentityAccessor, IContextAccessor, INetworkContextAccessor, UserContext, Factory, IBaseAccessor, AuthConfig, CookieOptions, SetupAction, HttpClientConfig, LogLevel, Dictionary, AuthPolicy, ResponseDto, IHandler, ResultType, ISpecification, CacheConfig, DbConfig, IReadDao, IReadDataSource, IMapper, IRepository, IWriteDataSource, IController, AppError } from '@xeno-js/shared';
+export * from '@xeno-js/shared';
+export { Query as BaseQuery } from '@xeno-js/shared';
+import { SupabaseClientOptions } from '@supabase/supabase-js';
+import { Client } from '@libsql/client/web';
+import { LibSQLDatabase } from 'drizzle-orm/libsql';
+import { NodePgDatabase } from 'drizzle-orm/node-postgres';
+export * from 'drizzle-orm';
+export { Query } from 'drizzle-orm';
+
+/**
+ * @description This file defines the injection tokens used for dependency injection in the application.
+ * Injection tokens are unique identifiers that are used to register and resolve dependencies in the container.
+ * They can be symbols, strings, or classes, but using symbols is a common practice to avoid naming collisions.
+ *
+ * @author Xeno
+ * @version 1.0.0
+ * @since 2025-09-30
+ * @link https://github.com/xeno-js/xeno-js
+ */
+interface ApplicationRegistry<T = unknown, Ttx = unknown> {
+    readonly ALLOW_ORIGIN: IAllowOrigin;
+    readonly ALLOW_METHOD: IAllowMethod;
+    /** @description Token used to register and resolve the AuthorizationPipeline instance in the dependency injection container.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    readonly AUTHORIZATION_PIPELINE: IPipelineBehavior<IRequest, unknown>;
+    /** @description Token used to register and resolve the AuthService instance in the dependency injection container.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    readonly AUTH_SERVICE: IExtendendService;
+    readonly BASE_AUTH_SERVICE: IBaseAuthService;
+    /** @description Token used to register and resolve the BearerTokenExtractor instance in the dependency injection container.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    readonly BEARER_TOKEN_EXTRACTOR: IServiceExtractor<HttpHeaders, Optional<string>>;
+    /** @description Token used to register and resolve the InMemoryCache instance in the dependency injection container.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    readonly CACHE: ICache;
+    /** @description Token used to register and resolve the CacheKeyBuilder instance in the dependency injection container.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    readonly CACHE_KEY_BUILDER: ICacheKeyBuilder;
+    /** @description Token used to register and resolve the ClaimsIdentityMapper instance in the dependency injection container.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    readonly CLAIMS_IDENTITY_MAPPER: IBaseMapper<AuthClaims, Identity>;
+    /** @description Token used to register and resolve the CommandPipeline behaviors in the dependency injection container.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    readonly COMMAND_PIPELINES_BEHAVIOR: IPipelineBehavior<ICommand, unknown>;
+    /** @description Token used to register and resolve the CompositePipeline instance in the dependency injection container.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    readonly COMPOSITE_PIPELINE: IPipelineBehavior<IQuery, unknown>;
+    /** @description Token used to register and resolve the ConcurrencyRetryPipeline instance in the dependency injection container.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    readonly CONCURRENCY_RETRY_PIPELINE: IPipelineBehavior<ICommand, unknown>;
+    /** @description Token used to register and resolve the ConcurrencyService instance in the dependency injection container.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    readonly CONCURRENCY_SERVICE: IConcurrencyService;
+    /** @description Token used to register and resolve the ConfigurationService instance in the dependency injection container.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    readonly CONFIGURATION_SERVICE: IConfigurationService;
+    /** @description Token used to register and resolve the ConsoleLogger instance in the dependency injection container.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    readonly CONSOLE_LOGGER: ILoggerClient;
+    /** @description Token used to register and resolve the DbContext instance in the dependency injection container.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    readonly DB_CONTEXT: T;
+    /** @description Token used to register and resolve the ExceptionPipeline instance in the dependency injection container.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    readonly EXCEPTION_PIPELINE: IPipelineBehavior<IRequest, unknown>;
+    /** @description Token used to register and resolve the GateKeeper instance in the dependency injection container.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    readonly GATE_KEEPER: IGateKeeper;
+    /** @description Token used to register and resolve the IdempotencyPipeline instance in the dependency injection container.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    readonly IDEMPOTENCY_PIPELINE: IPipelineBehavior<ICommand, unknown>;
+    /** @description Token used to register and resolve the IdempotencyStore instance in the dependency injection container.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    readonly IDEMPOTENCY_STORE: IIdempotencyStore;
+    /** @description Token used to register and resolve the Logger instance in the dependency injection container.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    readonly LOGGER: ILogger;
+    /** @description Token used to register and resolve the LoggingPipeline instance in the dependency injection container.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    readonly LOGGING_PIPELINE: IPipelineBehavior<IRequest, unknown>;
+    /** @description Token used to register and resolve the Mediator instance in the dependency injection container.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    readonly MEDIATOR: IMediator;
+    /** @description Token used to register and resolve the RequestContextMiddleware in the dependency injection container.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    readonly MIDDLEWARE: IMiddleware<HttpHeaders>;
+    readonly AUTH_MIDDLEWARE: IMiddleware<HttpHeaders>;
+    readonly CSRF_MIDDLEWARE: IMiddleware<HttpHeaders>;
+    readonly ALLOW_ORIGIN_MIDDLEWARE: IMiddleware<HttpHeaders>;
+    readonly CORS_MIDDLEWARE: IMiddleware<HttpHeaders>;
+    readonly METHOD_CHECK_MIDDLEWARE: IMiddleware<HttpHeaders>;
+    readonly OPTIONS_MIDDLEWARE: IMiddleware<HttpHeaders>;
+    readonly REQUEST_CONTEXT_MIDDLEWARE: IMiddleware<HttpHeaders>;
+    readonly RATE_LIMITER_MIDDLEWARE: IMiddleware<HttpHeaders>;
+    /** @description Token used to register and resolve the PerformancePipeline instance in the dependency injection container.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    readonly PERFORMANCE_PIPELINE: IPipelineBehavior<IRequest, unknown>;
+    /** @description Token used to register and resolve the PermissionAuthorizationPipeline instance in the dependency injection container.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    readonly PERMISSION_AUTHORIZATION_PIPELINE: IStrategy<IRequest>;
+    /** @description Token used to register and resolve the PinoLogger instance in the dependency injection container.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    readonly PINO_LOGGER: ILoggerClient;
+    /** @description Token used to register and resolve the PolicyRegistry instance in the dependency injection container.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    readonly POLICY_REGISTRY: IPolicyRegistry;
+    /** @description Token used to register and resolve the QueryCachingPipeline instance in the dependency injection container.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    readonly QUERY_CACHING_PIPELINE: IPipelineBehavior<IQuery, unknown>;
+    /** @description Token used to register and resolve the QueryPipeline behaviors in the dependency injection container.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    readonly QUERY_PIPELINES_BEHAVIOR: IPipelineBehavior<IQuery, unknown>;
+    /** @description Token used to register and resolve the RoutesRegistry instance in the dependency injection container.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    readonly REGISTRY_ROUTES: Record<`/${string}`, Record<HttpMethod, 'isPublic'>>;
+    /** @description Token used to register and resolve the RequestContext instance in the dependency injection container.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    readonly REQUEST_CONTEXT: IRequestContext<RequestContext, ApplicationRegistry<T>>;
+    /** @description Token used to register and resolve the IServiceResilience instance in the dependency injection container.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    readonly RESILIENCE_CLIENT: IServiceResilience;
+    /** @description Token used to register and resolve the RoleAuthorizationPipeline instance in the dependency injection container.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    readonly ROLE_AUTHORIZATION_PIPELINE: IStrategy<IRequest>;
+    /** @description Token used to register and resolve the SchemaValidationStrategy instance in the dependency injection container.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    readonly SCHEMA_VALIDATION_STRATEGY: IStrategy<IRequest, boolean>;
+    /** @description Token used to register and resolve the SentryLogger instance in the dependency injection container.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    readonly SENTRY_LOGGER: ILoggerClient;
+    /** @description Token used to register and resolve the ServiceContainer instance in the dependency injection container.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    readonly SERVICE_CONTAINER: IServiceContainer;
+    /** @description Token used to register and resolve the ServiceExtractor instance in the dependency injection container.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    readonly SERVICE_EXTRACTOR: IServiceExtractor<HttpHeaders, Metadata>;
+    /** @description Token used to register and resolve the ServiceScopeFactory instance in the dependency injection container.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    readonly SERVICE_SCOPE_FACTORY: IFactory<void, IServiceScope>;
+    /** @description Token used to register and resolve the TenantAuthorizationPipeline instance in the dependency injection container.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    readonly TENANT_AUTHORIZATION_PIPELINE: IStrategy<IRequest>;
+    /** @description Token used to register and resolve the TransactionState instance in the dependency injection container.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    readonly TRANSACTION_STATE: ITransactionState<Ttx>;
+    /** @description Token used to register and resolve the UnitOfWork instance in the dependency injection container.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    readonly UNIT_OF_WORK: IUnitOfWork & IDisposable;
+    /** @description Token used to register and resolve the UserAuthorizationPipeline instance in the dependency injection container.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    readonly USER_AUTHORIZATION_PIPELINE: IStrategy<IRequest>;
+    /** @description Token used to register and resolve the ValidationPipeline instance in the dependency injection container.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    readonly VALIDATION_PIPELINE: IPipelineBehavior<IRequest, unknown>;
+    /** @description Token used to register and resolve the ZodValidator instance in the dependency injection container.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    readonly ZOD_VALIDATOR: IValidatorService;
+    /** @description Token used to register and resolve the IIdentityAccessor in the dependency injection container, allowing access only to current user identity information.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    readonly IDENTITY_ACCESSOR: IIdentityAccessor;
+    /** @description Token used to register and resolve the IServiceScopeAccessor in the dependency injection container, granting controlled access to the current request scope.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    readonly SERVICE_SCOPE_ACCESSOR: IServiceScopeAccessor<ApplicationRegistry<T>>;
+    /** @description Token used to register and resolve the IContextAccessor instance in the dependency injection container to fetch execution context properties.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    readonly CONTEXT_ACCESSOR: IContextAccessor<RequestContext>;
+    /** @description Token used to register and resolve the INetworkContextAccessor instance in the dependency injection container to fetch networking/observability context data.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    readonly NETWORK_CONTEXT_ACCESSOR: INetworkContextAccessor;
+    /** @description Token used to register and resolve the UserContext factory in the dependency injection container.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    readonly USER_CONTEXT_FACTORY: IFactory<void, UserContext>;
+}
+
+/**
+ * @fileoverview Defines the IServiceScope interface for scoped dependency injection.
+ *
+ * @author Xeno
+ * @version 1.0.0
+ * @since 2025-09-30
+ * @link https://github.com/xeno-js/xeno-js
+ */
+/**
+ * @description Represents a logical scope for resolving scoped services,
+ * mimicking the .NET `IServiceScope` pattern.
+ *
+ * A scope is created by {@link IServiceContainer.createScope} and provides
+ * its own isolated instance cache for services registered with scoped lifetime.
+ * Singleton and transient services are still resolved through the root container.
+ *
+ * Call {@link dispose} when the scope is no longer needed to release all
+ * scoped instances and invalidate the scope.
+ *
+ * @author Xeno
+ * @version 1.0.0
+ * @since 2025-09-30
+ * @link https://github.com/xeno-js/xeno-js
+ */
+interface IServiceScope<Registry extends ApplicationRegistry<unknown> = ApplicationRegistry<unknown>> extends IDisposable {
+    /**
+     * Resolves and returns the service registered under the given token.
+     * Scoped services can only be resolved through a scope;
+     * resolving them directly from the root container throws an error.
+     *
+     * @param token - The injection token identifying the service to resolve.
+     * @returns The resolved service instance of type `T`.
+     * @throws An error if no registration is found for the given token.
+     * @throws An error if the scope has already been disposed.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    resolve<K extends keyof Registry>(token: K): Registry[K];
+}
+
+/**
+ * @fileoverview Defines the IServiceContainer interface for a dependency injection container.
+ *
+ * @author Xeno
+ * @version 1.0.0
+ * @since 2025-09-30
+ * @link https://github.com/xeno-js/xeno-js
+ */
+interface IServiceProvider<Registry extends ApplicationRegistry<unknown> = ApplicationRegistry<unknown>> {
+    /**
+     * Resolves and returns the service registered under the given token.
+     * Scoped services can only be resolved through a scope;
+     * resolving them directly from the root container throws an error.
+     *
+     * @param token - The injection token identifying the service to resolve.
+     * @returns The resolved service instance of type `T`.
+     * @throws An error if no registration is found for the given token.
+     * @throws An error if the scope has already been disposed.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    resolve<K extends keyof Registry>(token: K): Registry[K];
+}
+/**
+ * @description Agnostic contract for a dependency injection container that mimics
+ * the .NET ServiceCollection builder pattern.
+ *
+ * Each registration method returns `this` to enable a fluent builder chain.
+ * Dependencies are expressed as an ordered array of injection tokens
+ * that the container will resolve and inject into the constructor.
+ *
+ * @author Xeno
+ * @version 1.0.0
+ * @since 2025-09-30
+ * @link https://github.com/xeno-js/xeno-js
+ */
+interface IServiceContainer<Registry extends ApplicationRegistry<unknown> = ApplicationRegistry<unknown>> extends IServiceProvider<Registry>, IDisposable {
+    /**
+     * Registers an implementation under the given token with **singleton** lifetime.
+     * A single instance is created on first resolution and reused for every
+     * subsequent call within the container's lifetime.
+     *
+     * @param token - The unique injection token that identifies this service binding.
+     * @param factory - Factory function that creates the service instance, receiving the scope as an argument.
+     * @returns The container instance to allow method chaining.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    addSingleton<K extends keyof Registry>(token: K, factory: Factory<Registry[K], [IServiceScope<Registry>]>): this;
+    /**
+     * Registers an implementation under the given token with **transient** lifetime.
+     * A new instance is created on every call to {@link resolve}.
+     *
+     * @param token - The unique injection token that identifies this service binding.
+     * @param factory - Factory function that creates the service instance, receiving the scope as an argument.
+     * @returns The container instance to allow method chaining.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    addTransient<K extends keyof Registry>(token: K, factory: Factory<Registry[K], [IServiceScope<Registry>]>): this;
+    /**
+     * Registers an implementation under the given token with **scoped** lifetime.
+     * One instance is created per logical scope (e.g. per HTTP request).
+     * Scoped services must be resolved through an {@link IServiceScope} obtained
+     * via {@link createScope}; resolving them directly from the root container throws.
+     *
+     * @param token - The unique injection token that identifies this service binding.
+     * @param factory - Factory function that creates the service instance, receiving the scope as an argument.
+     * @returns The container instance to allow method chaining.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    addScoped<K extends keyof Registry>(token: K, factory: Factory<Registry[K], [IServiceScope<Registry>]>): this;
+    /**
+     * Creates a new {@link IServiceScope}.
+     *
+     * The returned scope shares singleton instances with the root container
+     * and maintains its own isolated cache for scoped services.
+     * Call {@link IServiceScope.dispose} when the scope is no longer needed.
+     *
+     * @returns A new scope instance.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    createScope(): IServiceScope<Registry>;
+}
+
+/**
+ * @fileoverview Defines the ServiceDescriptor type for service registrations.
+
+   *
+   * @author Xeno
+   * @version 1.0.0
+   * @since 2025-09-30
+   * @link https://github.com/xeno-js/xeno-js
+   */
+/**
+ * @description The possible lifetimes for a service registration, determining
+ * how instances are managed and cached by the container.
+
+   *
+   * @author Xeno
+   * @version 1.0.0
+   * @since 2025-09-30
+   * @link https://github.com/xeno-js/xeno-js
+   */
+type Lifetime = 'singleton' | 'transient' | 'scoped';
+/**
+ * @description Describes a service registration in the container, including
+ * the implementation constructor, its dependencies, and its lifetime.
+
+   *
+   * @author Xeno
+   * @version 1.0.0
+   * @since 2025-09-30
+   * @link https://github.com/xeno-js/xeno-js
+   */
+interface ServiceDescriptor<T, TRegistry extends ApplicationRegistry<unknown> = ApplicationRegistry<unknown>> {
+    /**
+     * @description The injection token that uniquely identifies this service registration.
+    
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    readonly token: keyof TRegistry;
+    /**
+     * @description The lifetime of the service, determining how instances are
+     * managed and cached by the container.
+    
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    readonly lifetime: Lifetime;
+    /**
+     * @description Factory function to create the service instance.
+     * This factory will be used instead of the constructor.
+    
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    readonly factory: (container: IServiceProvider<TRegistry>) => T;
+}
+
+/**
+ * @description This file defines the types for the execution context used in the application. The execution context includes the request context, which contains information about the identity of the user or system executing the request, as well as network and tracing contexts for observability. Additionally, it includes a service scope for managing dependencies during the execution of a request.
+ *
+ * @author Xeno
+ * @version 1.0.0
+ * @since 2025-09-30
+ * @link https://github.com/xeno-js/xeno-js
+ */
+
+/**
+ * The ExecutionContext interface represents the context of a request execution, encapsulating the request context and the service scope. The request context contains information about the identity of the user or system executing the request, as well as network and tracing contexts for observability. The service scope allows for managing dependencies during the execution of a request, ensuring that services are properly scoped and disposed of after the request is processed.
+
+   *
+   * @author Xeno
+   * @version 1.0.0
+   * @since 2025-09-30
+   * @link https://github.com/xeno-js/xeno-js
+   */
+interface ExecutionContext<TRegistry extends ApplicationRegistry = ApplicationRegistry> {
+    /** The request context containing information about the identity, network, and tracing contexts for the current request execution.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    context: RequestContext;
+    /** The service scope for managing dependencies during the execution of a request. This allows for proper scoping and disposal of services after the request is processed.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    scope: IServiceScope<TRegistry>;
+}
+
+/**
+ * @fileoverview Defines the IRequestContext interface for managing user identity context within the application.
+ *
+ * @author Xeno
+ * @version 1.0.0
+ * @since 2025-09-30
+ * @link https://github.com/xeno-js/xeno-js
+ */
+
+/**
+ * An interface for managing user identity context within the application. This interface provides methods for executing asynchronous functions with the current user's identity context and retrieving the current user's identity information. It allows for seamless integration of identity management into various parts of the application, ensuring that identity-related data is properly propagated and accessible when needed.
+ *
+ * @author Xeno
+ * @version 1.0.0
+ * @since 2025-09-30
+ * @link https://github.com/xeno-js/xeno-js
+ */
+interface IRequestContext<TCtx, TRegistry extends ApplicationRegistry = ApplicationRegistry> extends IBaseAccessor<TCtx>, IServiceScopeAccessor<TRegistry> {
+    /**
+     * Executes the provided asynchronous function with the current user's identity context. This allows the function to access identity information such as user ID, roles, and correlation ID while performing its operations. The function will be executed within the scope of the current request's identity, ensuring that any identity-related data is properly propagated throughout the execution flow.
+     * @param ctx The current user's identity context.
+     * @param fn An asynchronous function that takes the current user's identity as an argument and returns a promise of type T. This function will be executed with the identity context of the current request.
+     * @returns A promise that resolves to the result of the provided function, allowing the caller to handle the outcome of the operation performed within the identity context.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    runAsync<T = unknown>(ctx: TCtx, fn: () => Promise<T>): Promise<T>;
+    updateIdentity(identity: Identity): void;
+}
+/**
+ * @description The IIdentityAccessor interface is a contract that defines the structure and behavior of an identity accessor within the application. It provides a method for retrieving the current user's identity information, including user ID, roles, and correlation ID. This interface is essential for managing user identity and ensuring that identity-related data is accessible when needed.
+ *
+ *
+ * @author Xeno
+ * @version 1.0.0
+ * @since 2025-09-30
+ * @link https://github.com/xeno-js/xeno-js
+ */
+interface IServiceScopeAccessor<TRegistry extends ApplicationRegistry<unknown> = ApplicationRegistry<unknown>> {
+    /**
+     * Retrieves the current service scope, which allows for managing dependencies during the execution of a request. This method enables access to the service scope, ensuring that services are properly scoped and disposed of after the request is processed.
+     * @returns An object representing the current service scope, allowing for resolution of dependencies and management of services during the execution of a request.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    getScope(): Optional<IServiceScope<TRegistry>>;
+}
+
+/**
+ * @description Represents a module that can be registered with the service container.
+ *
+ * @template TOptions - The type of configuration options for the module.
+
+   *
+   * @author Xeno
+   * @version 1.0.0
+   * @since 2025-09-30
+   * @link https://github.com/xeno-js/xeno-js
+   */
+interface IModule<TRegistry extends ApplicationRegistry<unknown> = ApplicationRegistry<unknown>, TOptions = unknown> {
+    /**
+     * @description Configures the module with the provided options.
+     *
+     * @param container - The service container to register services with.
+     * @param opts - The configuration options for the module.
+    
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    configure(container: IServiceContainer<TRegistry>, opts?: Optional<TOptions>): Promise<void>;
+}
+
+/**
+ * @description Interface for the allow method service.
+ *
+ * @author Xeno
+ * @version 1.0.0
+ * @since 2025-09-30
+ * @link https://github.com/xeno-js/xeno-js
+ */
+interface IAllowMethod {
+    /** @description Check if the given method is allowed for the given path.
+     * @param path The path to check.
+     * @param method The method to check.
+     * @returns True if the method is allowed, false otherwise.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    check(path: string, method: HttpMethod): boolean;
+}
+
+/**
+ * @description Interface for the allow origin service.
+ *
+ * @author Xeno
+ * @version 1.0.0
+ * @since 2025-09-30
+ * @link https://github.com/xeno-js/xeno-js
+ */
+interface IAllowOrigin {
+    /** @description Check if the given origin is allowed.
+     * @param origin The origin to check.
+     * @returns True if the origin is allowed, false otherwise.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    isAllowed(origin: Optional<string>): boolean;
+}
+
+interface ISsrCookie {
+    name: string;
+    value: string;
+}
+interface ISsrCookieToSet extends ISsrCookie {
+    options?: CookieOptions;
+}
+interface ISsrCookieHandler {
+    getAll(): ISsrCookie[];
+    setAll(cookies: ISsrCookieToSet[]): void;
+}
+interface AuthSsrConfig<TOption, TRegistry extends ApplicationRegistry = ApplicationRegistry> extends AuthConfig<TOption> {
+    ssrOpts: Optional<(container: IServiceContainer<TRegistry>) => ISsrCookieHandler>;
+}
+
+/**
+ * @description This file defines the ResilienceConfig interface, which specifies the configuration options for implementing resilience features such as retries, circuit breakers, and bulkheads in service calls. The ResilienceConfig interface includes properties for configuring retry attempts, base delay, maximum delay, consecutive failures for circuit breakers, half-open timeout, and maximum concurrent operations for bulkheads. This configuration can be used to enhance the reliability of service interactions by automatically handling transient faults and preventing cascading failures in distributed systems.
+
+   *
+   * @author Xeno
+   * @version 1.0.0
+   * @since 2025-09-30
+   * @link https://github.com/xeno-js/xeno-js
+   */
+interface ResilienceConfig {
+    /**
+     * @description Configuration for retry mechanism, including the number of retry attempts, base delay in milliseconds for the first retry, and maximum delay in milliseconds for subsequent retries. This configuration allows for implementing an exponential backoff strategy to manage retries effectively and avoid overwhelming the service with rapid retry attempts.
+    
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    retry: {
+        /** @description The number of retry attempts to be made before giving up on the operation. This helps to ensure that transient faults are handled gracefully without overwhelming the service with excessive retries.
+         *
+         * @author Xeno
+         * @version 1.0.0
+         * @since 2025-09-30
+         * @link https://github.com/xeno-js/xeno-js
+         */
+        attempts: Optional<number>;
+        /** @description The base delay in milliseconds for the first retry attempt. This value is used to calculate the delay for subsequent retries using an exponential backoff strategy, which helps to manage retries effectively and avoid overwhelming the service with rapid retry attempts.
+         *
+         * @author Xeno
+         * @version 1.0.0
+         * @since 2025-09-30
+         * @link https://github.com/xeno-js/xeno-js
+         */
+        baseDelayMs: Optional<number>;
+        /** @description The maximum delay in milliseconds for subsequent retry attempts. This value is used to cap the delay for retries when using an exponential backoff strategy, ensuring that the delay does not grow indefinitely and allowing for a reasonable retry strategy that balances between retrying too quickly and waiting too long.
+         *
+         * @author Xeno
+         * @version 1.0.0
+         * @since 2025-09-30
+         * @link https://github.com/xeno-js/xeno-js
+         */
+        maxDelayMs: Optional<number>;
+    };
+    /**
+     * @description Configuration for circuit breaker mechanism, including the number of consecutive failures required to trip the circuit breaker and the timeout duration in milliseconds for the half-open state. This configuration helps to prevent cascading failures by temporarily blocking calls to a service that is experiencing issues, allowing it time to recover before accepting new requests.
+    
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    circuitBreaker: {
+        /** @description The number of consecutive failures required to trip the circuit breaker. When the number of consecutive failures reaches this threshold, the circuit breaker will open, preventing further calls to the service until it is allowed to half-open after a specified timeout. This helps to prevent cascading failures by temporarily blocking calls to a service that is experiencing issues, allowing it time to recover before accepting new requests.
+         *
+         * @author Xeno
+         * @version 1.0.0
+         * @since 2025-09-30
+         * @link https://github.com/xeno-js/xeno-js
+         */
+        consecutiveFailures: Optional<number>;
+        /** @description The timeout duration in milliseconds for the half-open state of the circuit breaker. After the circuit breaker has been tripped and is in the open state, it will transition to the half-open state after this timeout duration. In the half-open state, a limited number of calls will be allowed to test if the service has recovered. If the calls succeed, the circuit breaker will close and allow normal operation to resume. If the calls fail, the circuit breaker will open again, preventing further calls until the next timeout period. This configuration helps to manage the recovery process of a service that is experiencing issues and ensures that it can return to normal operation gracefully.
+         *
+         * @author Xeno
+         * @version 1.0.0
+         * @since 2025-09-30
+         * @link https://github.com/xeno-js/xeno-js
+         */
+        halfOpenTimeoutMs: Optional<number>;
+    };
+    /**
+     * @description Configuration for bulkhead mechanism, including the maximum number of concurrent operations allowed. This configuration helps to isolate failures and prevent resource exhaustion by limiting the number of concurrent calls to a service, ensuring that other parts of the system can continue to function even if one service is experiencing issues.
+    
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    bulkhead: {
+        /** @description The maximum number of concurrent operations allowed. This helps to isolate failures and prevent resource exhaustion by limiting the number of concurrent calls to a service, ensuring that other parts of the system can continue to function even if one service is experiencing issues.
+         *
+         * @author Xeno
+         * @version 1.0.0
+         * @since 2025-09-30
+         * @link https://github.com/xeno-js/xeno-js
+         */
+        maxConcurrent: Optional<number>;
+    };
+}
+
+/**
+ * @description HttpCoreConfig is an interface that defines the configuration options for the core HTTP functionality of the application. It includes two properties: 'http' of type HttpConfig, which specifies the configuration for the HTTP client, and 'resilience' of type ResilienceConfig, which provides the settings for implementing resilience strategies such as retries, circuit breakers, and timeouts. This interface allows for a centralized configuration of both HTTP and resilience features in the application.
+ *
+ * @author Xeno
+ * @version 1.0.0
+ * @since 2025-09-30
+ * @link https://github.com/xeno-js/xeno-js
+ */
+interface HttpCoreConfig<TRegistry extends ApplicationRegistry<unknown> = ApplicationRegistry<unknown>> {
+    /** @description A unique token used for identifying the RemoteDataSource instance in the dependency injection container.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    dataSourceToken: SetupAction<IServiceContainer<TRegistry>>;
+    /** @description The configuration options for the HTTP client, including default headers, base URL, and timeout settings.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    http: HttpConfig<TRegistry>;
+    /** @description The configuration options for implementing resilience strategies, including retries, circuit breakers, and timeouts. This allows for enhancing the reliability of service interactions by automatically handling transient faults and preventing cascading failures in distributed systems.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    resilience: ResilienceConfig;
+}
+/**
+ * @description HttpConfig is an interface that defines the configuration options for an HTTP client. It includes a required 'client' property of type HttpClientConfig, which specifies the default headers, base URL, and timeout for the HTTP client. Additionally, it has an optional 'resilience' property that indicates whether resilience features are enabled and provides the corresponding ResilienceConfig if they are.
+ *
+ * @author Xeno
+ * @version 1.0.0
+ * @since 2025-09-30
+ * @link https://github.com/xeno-js/xeno-js
+ */
+interface HttpConfig<TRegistry extends ApplicationRegistry<unknown> = ApplicationRegistry<unknown>> {
+    /** @description A unique token used for identifying the HTTP client configuration in the dependency injection container.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    token: keyof TRegistry;
+    /** @description The configuration options for the HTTP client, including default headers, base URL, and timeout settings.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    client: HttpClientConfig;
+}
+
+/**
+ * @description Interface defining the structure of a logger configuration object. This includes properties such as the minimum log level that should be captured by the logger. The log level determines the severity of log messages that will be processed and forwarded to the logging clients, allowing developers to control the verbosity of logs based on the needs of the application and its operational context.
+ *
+ *
+ * @author Xeno
+ * @version 1.0.0
+ * @since 2025-09-30
+ * @link https://github.com/xeno-js/xeno-js
+ */
+interface LoggerConfig<TRegistry extends ApplicationRegistry = ApplicationRegistry> {
+    /**
+     * @description
+     * The level property specifies the minimum log level that should be captured by the logger. Log levels typically include DEBUG, INFO, WARN, and ERROR, with each level representing a different severity of log messages. By setting the log level, developers can control the verbosity of the logs and ensure that only relevant information is captured based on the needs of the application and its operational context.
+    
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    level: Optional<LogLevel>;
+    /** @description Flag to enable or disable console logging. If set to true, log messages will be output to the console. If set to false or not defined, console logging will be disabled, and log messages will not be output to the console.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    console: boolean;
+    /** @description Optional configuration for Sentry logger integration. If provided and enabled, the application will use Sentry as a logging client to capture and report log messages to the Sentry service. The configuration includes specific details for Sentry integration, such as the Data Source Name (DSN) and environment, allowing for flexible and modular logging configuration in the application.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    sentry: {
+        /** @description Optional configuration for Sentry logger integration, including details such as the Data Source Name (DSN) and environment. If provided, this configuration will be used to initialize the Sentry logger client for capturing and reporting log messages to the Sentry service. If not defined, default Sentry configuration settings will be used.
+         *
+         * @author Xeno
+         * @version 1.0.0
+         * @since 2025-09-30
+         * @link https://github.com/xeno-js/xeno-js
+         */
+        config: Optional<SentryLoggerConfig>;
+    };
+    /** @description Optional configuration for Pino logger integration. If provided and enabled, the application will use Pino as a logging client to capture and manage log messages. The configuration includes specific details for Pino integration, such as the destination for log output, allowing for flexible and modular logging configuration in the application.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    pino: {
+        /** @description Optional configuration for Pino logger integration, including details such as the destination for log output. If provided, this configuration will be used to initialize the Pino logger client for capturing and managing log messages. If not defined, default Pino configuration settings will be used.
+         *
+         * @author Xeno
+         * @version 1.0.0
+         * @since 2025-09-30
+         * @link https://github.com/xeno-js/xeno-js
+         */
+        config: Optional<PinoLoggerConfig>;
+    };
+    /** @description Optional array of custom logger clients to be used in addition to the built-in console, Sentry, and Pino loggers. If provided, these custom loggers will be registered and used for capturing and managing log messages based on their respective configurations. If not defined or empty, only the enabled built-in loggers will be used.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    customLoggers: Optional<(container: IServiceScope<TRegistry>) => ILoggerClient>[];
+}
+/**
+ * @description Interface defining the structure of the configuration object required to initialize a logger. This includes properties such as the Data Source Name (DSN) for connecting to the logging service, the environment in which the application is running (e.g., development, production), and the minimum log level that should be captured by the logger.
+
+   *
+   * @author Xeno
+   * @version 1.0.0
+   * @since 2025-09-30
+   * @link https://github.com/xeno-js/xeno-js
+   */
+interface SentryLoggerConfig {
+    /**
+     * @description
+     * The Data Source Name (DSN) is a string that provides the necessary information for the logger to connect to the logging service. It typically includes the protocol, public key, secret key, host, and project ID. The DSN is essential for authenticating and routing log data to the correct destination in the logging infrastructure.
+    
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    dsn: Optional<string>;
+    /**
+     * @description
+     * The environment property indicates the context in which the application is running, such as 'development', 'staging', or 'production'. This information can be used by the logging service to categorize and filter logs based on the environment, allowing for better organization and analysis of log data.
+    
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    environment: Optional<string>;
+}
+/**
+ * @description Interface defining the structure of the configuration object required to initialize a Pino logger. This includes properties such as the destination for log output, which can be a file path, a stream, or a logging service endpoint. By configuring the destination, developers can control where the log data is stored or sent, enabling integration with various logging infrastructures and facilitating log management and analysis.
+
+   *
+   * @author Xeno
+   * @version 1.0.0
+   * @since 2025-09-30
+   * @link https://github.com/xeno-js/xeno-js
+   */
+interface PinoLoggerConfig {
+    /**
+     * @description
+     * The destination property specifies the output destination for the logs generated by the Pino logger. This can be a file path, a stream, or a logging service endpoint. By configuring the destination, developers can control where the log data is stored or sent, enabling integration with various logging infrastructures and facilitating log management and analysis.
+    
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    destination?: Optional<Destination>;
+    /** @description Optional environment name for the Pino logger configuration. This can be used to specify the context in which the application is running (e.g., development, production) and can help with categorizing and filtering log messages based on the environment.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    env?: Optional<string>;
+    /** @description Optional file path for the Pino logger configuration. If specified, log messages will be written to the specified file instead of the default output destination. This allows for flexible log management and storage based on application requirements.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    filePath?: Optional<string>;
+    /** @description Optional flag to enable pretty printing of log messages. When set to true, log messages will be formatted in a more human-readable way, which can be useful for development and debugging purposes.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    prettyPrint?: Optional<boolean>;
+}
+type Destination = 'stdout' | 'file';
+
+/**
+ * @description Configuration for the middleware.
+ *
+ * @author Xeno
+ * @version 1.0.0
+ * @since 2025-09-30
+ * @link https://github.com/xeno-js/xeno-js
+ */
+interface MiddlewareConfig {
+    /**
+     * @description
+     * The isSSR property is a boolean flag that indicates whether the application is running in a server-side rendering (SSR) environment. In an SSR environment, the application is rendered on the server-side and then sent to the client-side for display. This property is useful for configuring middleware or other components that may behave differently in an SSR environment. For example, certain middleware may need to be disabled or modified when running in an SSR environment to prevent issues with server-side rendering. By setting the isSSR property to true or false, developers can configure middleware or other components to behave appropriately in an SSR environment.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    isSSR: boolean;
+    /**
+     * @description
+     * The rateLimite property is an object that contains two properties: maxRequests and windowSeconds. These properties are used to configure rate limiting for the application. Rate limiting is a technique used to prevent abuse or excessive use of a system or service by limiting the number of requests that can be made within a given time period. The maxRequests property specifies the maximum number of requests that can be made within the specified windowSeconds, and the windowSeconds property specifies the duration of the window in seconds.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    rateLimite: {
+        /**
+         * @description
+         * The maxRequests property specifies the maximum number of requests that can be made within the specified windowSeconds. This property is used to configure rate limiting for the application. Rate limiting is a technique used to prevent abuse or excessive use of a system or service by limiting the number of requests that can be made within a given time period. The maxRequests property specifies the maximum number of requests that can be made within the specified windowSeconds, and the windowSeconds property specifies the duration of the window in seconds.
+         *
+         * @author Xeno
+         * @version 1.0.0
+         * @since 2025-09-30
+         * @link https://github.com/xeno-js/xeno-js
+         */
+        maxRequests: Optional<number>;
+        /**
+         * @description
+         * The windowSeconds property specifies the duration of the window in seconds. This property is used to configure rate limiting for the application. Rate limiting is a technique used to prevent abuse or excessive use of a system or service by limiting the number of requests that can be made within a given time period. The windowSeconds property specifies the duration of the window in seconds, and the maxRequests property specifies the maximum number of requests that can be made within the specified windowSeconds.
+         *
+         * @author Xeno
+         * @version 1.0.0
+         * @since 2025-09-30
+         * @link https://github.com/xeno-js/xeno-js
+         */
+        windowSeconds: Optional<number>;
+    };
+    /**
+     * @description
+     * The cors property is an optional property that can be used to configure Cross-Origin Resource Sharing (CORS) for the application. CORS is a mechanism that allows resources on a web page to be requested from another domain outside the domain from which the resource originated. The cors property is an object that contains properties to configure CORS, such as allowedOrigins, allowedMethods, allowedHeaders, and exposedHeaders.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    csrf: Optional<string>;
+    /**
+     * @description
+     * The cors property is an optional property that can be used to configure Cross-Origin Resource Sharing (CORS) for the application. CORS is a mechanism that allows resources on a web page to be requested from another domain outside the domain from which the resource originated. The cors property is an object that contains properties to configure CORS, such as allowedOrigins, allowedMethods, allowedHeaders, and exposedHeaders.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    optionsMiddleware: boolean;
+    /**
+     * @description
+     * The routeRegistry property is an optional property that can be used to configure the routing of HTTP requests in the application. It is an object that contains properties to define the routes and their corresponding HTTP methods. The routeRegistry property is used to map incoming HTTP requests to the appropriate route handlers, allowing the application to handle requests based on the defined routes and methods.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    routeRegistry: Optional<Dictionary<HttpMethod[]>>;
+    /**
+     * @description
+     * The trustedIpHeader property is an optional property that can be used to configure the trusted IP header for the application. It is a string that specifies the name of the header that contains the trusted IP address. This property is used to determine the trusted IP address of the client making the request, which can be useful for security and authentication purposes.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    trustedIpHeader: Optional<string>;
+    /**
+     * @description
+     * The allowOrigins property is an optional property that can be used to configure the allowed origins for the application. It is an array of strings that specifies the origins that are allowed to make requests to the application. This property is used to implement Cross-Origin Resource Sharing (CORS) and restrict access to the application based on the origin of the request.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    allowOrigins: Optional<string[]>;
+    /**
+     * @description
+     * The cors property is a boolean property that is used to enable or disable Cross-Origin Resource Sharing (CORS) for the application. CORS is a mechanism that allows resources on a web page to be requested from another domain outside the domain from which the first resource was served. This property is used to configure the CORS middleware that is responsible for handling CORS requests and responses.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    cors: boolean;
+}
+
+/**
+ * @description PipelineConfig defines the configuration options for the CQRS pipelines in the application. It includes settings for performance monitoring, authorization, validation, command bus, and query bus. Each section allows for enabling or disabling specific features and providing additional configuration details as needed. This configuration is used by the CqrsModule to set up the appropriate middleware and services in the dependency injection container based on the specified options.
+
+   *
+   * @author Xeno
+   * @version 1.0.0
+   * @since 2025-09-30
+   * @link https://github.com/xeno-js/xeno-js
+   */
+interface PipelineConfig<TRegistry extends ApplicationRegistry<unknown> = ApplicationRegistry<unknown>, TSchema = unknown> {
+    /** @description Configuration for performance monitoring, including the ability to set a threshold in milliseconds for logging slow operations. If enabled, the PerformancePipeline will log a warning whenever the execution of a command or query exceeds the specified threshold, helping to identify potential performance bottlenecks in the application. If the threshold is not defined, all operations will be monitored without duration-based filtering.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    performance: {
+        /** @description Optional threshold in milliseconds for logging slow operations. If defined, the PerformancePipeline will log a warning whenever the execution of a command or query exceeds this duration, allowing for performance monitoring and optimization. If not defined, all operations will be monitored without duration-based filtering.
+         *
+         * @author Xeno
+         * @version 1.0.0
+         * @since 2025-09-30
+         * @link https://github.com/xeno-js/xeno-js
+         */
+        thresholdMs: Optional<number>;
+    };
+    /** @description Configuration for authorization, allowing the enabling of authorization strategies based on tenant, policy, roles, and permissions. If enabled, the authorization pipeline will evaluate the specified strategies for each command or query, ensuring that only authorized users can perform certain actions. The configuration also includes the ability to define custom authorization strategies via injection tokens, providing flexibility in implementing application-specific access rules.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    authorization: {
+        /** @description Configuration for policy-based authorization, allowing the definition of a policy registry and the option to enable role-based or permission-based checks. If policy-based authorization is enabled, the authorization pipeline will include a strategy that evaluates the defined policies for each command or query, ensuring that users meet the necessary criteria based on their roles and permissions. The policy registry allows for central management of authorization policies, making it easier to maintain and update access rules across the application.
+         *
+         * @author Xeno
+         * @version 1.0.0
+         * @since 2025-09-30
+         * @link https://github.com/xeno-js/xeno-js
+         */
+        policies: Optional<Dictionary<AuthPolicy>>;
+        /** @description An optional array of custom authorization strategies defined via injection tokens. If provided, these strategies will be included in the authorization pipeline and evaluated for each command or query, allowing for custom logic to determine if a user is authorized to perform a specific action. This provides flexibility in implementing application-specific access rules that may not fit into standard tenant-based or policy-based checks. Each strategy should implement the IStrategy interface and return a boolean indicating whether the command or query is authorized.
+         *
+         * @author Xeno
+         * @version 1.0.0
+         * @since 2025-09-30
+         * @link https://github.com/xeno-js/xeno-js
+         */
+        customAuthorizationStrategy?: Optional<(container: IServiceScope<TRegistry>) => IStrategy<IRequest>>[];
+    };
+    /** @description Configuration for validation, allowing the enabling of validation based on Zod schemas or custom validation strategies. If enabled, the validation pipeline will validate commands and queries based on the specified criteria, ensuring that input data meets expectations before further processing. The configuration includes the ability to define Zod schemas for structural validation or to use custom strategies via injection tokens, providing flexibility in implementing application-specific validation rules.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    validation: {
+        /** @description An optional configuration for Zod-based validation, allowing the definition of schemas for validating the structure and content of commands and queries. If provided, the validation pipeline will use these schemas to validate incoming requests, ensuring that they conform to the expected format and contain valid data before being processed further. This provides a powerful and flexible way to enforce data integrity and prevent invalid input from causing issues in the application.
+         *
+         * @author Xeno
+         * @version 1.0.0
+         * @since 2025-09-30
+         * @link https://github.com/xeno-js/xeno-js
+         */
+        zod: Optional<SchemaConfig<TSchema>>;
+        /** @description An optional array of custom validation strategies defined via injection tokens. If provided, these strategies will be included in the validation pipeline and evaluated for each command or query, allowing for custom logic to determine if the input data is valid. This provides flexibility in implementing application-specific validation rules that may not fit into standard schema-based validation. Each strategy should implement the IStrategy interface and return a boolean indicating whether the command or query is valid.
+         *
+         * @author Xeno
+         * @version 1.0.0
+         * @since 2025-09-30
+         * @link https://github.com/xeno-js/xeno-js
+         */
+        customValidationStrategy?: Optional<(container: IServiceScope<TRegistry>) => IStrategy<IRequest, boolean>>[];
+    };
+    /** @description Configuration for the command bus, allowing the enabling of features such as idempotency and concurrency management. If enabled, the command bus pipeline will include specific behaviors to handle these features, such as acquiring locks to ensure idempotency or managing retries in case of concurrency conflicts. The configuration includes specific details for each feature, such as TTLs for idempotency locks or delay strategies for concurrency retries, providing granular control over how commands are processed and managed within the application.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    commandBus: {
+        idempotency: Optional<IdempotencyConfig>;
+        concurrency: Optional<ConcurrencyConfig>;
+    };
+    /** @description Configuration for the query bus, allowing the enabling of features such as result caching. If enabled, the query bus pipeline will include specific behaviors to handle caching, such as storing query results in a cache system and retrieving results from the cache when available. The configuration includes specific details for caching, such as settings for Redis integration or the ability to use a custom cache via injection tokens, providing flexibility in how query results are stored and retrieved within the application.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    queryBus: {
+        /** @description Flag to enable or disable query bus features. If set to true, the query bus pipeline will include additional behaviors based on the specified configuration, such as result caching. If set to false or not defined, the query bus will operate without these additional features, allowing queries to be processed in a standard manner without caching or other enhancements.
+         *
+         * @author Xeno
+         * @version 1.0.0
+         * @since 2025-09-30
+         * @link https://github.com/xeno-js/xeno-js
+         */
+        isEnabled: boolean;
+    };
+}
+/** @description Configuration for caching, allowing the enabling of Redis integration or the use of a custom cache. If enabled, the query bus and command bus (in case of idempotency) pipelines will use the configured cache system to store and retrieve data efficiently. The configuration includes specific details for Redis integration, such as host, port, and credentials, as well as the ability to define a custom cache via injection tokens, providing flexibility in how the cache is implemented and used within the application.
+ *
+ * @author Xeno
+ * @version 1.0.0
+ * @since 2025-09-30
+ * @link https://github.com/xeno-js/xeno-js
+ */
+interface SchemaConfig<TSchema> {
+    /** @description A record of Zod schemas, where each key represents a specific command or query type, and the corresponding value is the Zod schema used to validate that type. If provided, the validation pipeline will use these schemas to validate incoming requests, ensuring that they conform to the expected format and contain valid data before being processed further. This allows for powerful and flexible validation rules based on the structure and content of commands and queries.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    schemas: Dictionary<TSchema>;
+}
+/** @description Configuration for idempotency, allowing the definition of TTLs for locks and processed results. If enabled, the command bus pipeline will include specific behaviors to handle idempotency, such as acquiring locks to ensure that a command with the same ID is processed only once and storing the results of processed commands for a defined period. The configuration includes specific details for TTLs, such as the duration of the lock and the duration for which processed results are retained, providing granular control over how idempotency is managed within the application.
+ *
+ * @author Xeno
+ * @version 1.0.0
+ * @since 2025-09-30
+ * @link https://github.com/xeno-js/xeno-js
+ */
+interface IdempotencyConfig {
+    /** @description Optional TTL in seconds for the idempotency lock. This defines how long the lock should be held to prevent duplicate processing of commands with the same ID. If not defined, a default value will be used.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    lockTtlSeconds: Optional<number>;
+    /** @description Optional TTL in seconds for storing the results of processed commands. This defines how long the results of a processed command should be retained in the cache, allowing for retrieval if the same command is received again within that period. If not defined, a default value will be used.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    processedTtlSeconds: Optional<number>;
+}
+/** @description Configuration for concurrency management, allowing the definition of maximum retries and delay strategies for retries. If enabled, the command bus pipeline will include specific behaviors to handle concurrency conflicts, such as retrying a command in case of failure due to a conflict. The configuration includes specific details for retries, such as the maximum number of attempts and delay strategies (e.g., exponential backoff with jitter) between attempts, providing granular control over how concurrency is managed within the application.
+ *
+ * @author Xeno
+ * @version 1.0.0
+ * @since 2025-09-30
+ * @link https://github.com/xeno-js/xeno-js
+ */
+interface ConcurrencyConfig {
+    /** @description Optional maximum number of retry attempts in case of concurrency conflicts. This defines how many times the command bus should attempt to retry a command if it fails due to a concurrency issue, such as a version conflict in an optimistic concurrency control scenario. If not defined, a default value will be used.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    maxRetries?: Optional<number>; /** @description Optional configuration for delay strategies between retry attempts. This can include settings for exponential backoff, jitter, or fixed delays to manage the timing of retries in case of concurrency conflicts. If not defined, a default delay strategy will be used.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    delayConfig: {
+        /** @description Base delay in milliseconds for retries. This defines the initial delay before the first retry attempt in case of a concurrency conflict. If using an exponential backoff strategy, this base delay will be multiplied for each subsequent retry attempt. If not defined, a default value will be used.
+         *
+         * @author Xeno
+         * @version 1.0.0
+         * @since 2025-09-30
+         * @link https://github.com/xeno-js/xeno-js
+         */
+        baseDelayMs: number;
+        /** @description Optional maximum delay in milliseconds for retries. This defines the upper limit for the delay between retry attempts, preventing excessively long delays in case of multiple retries. If not defined, a default value will be used.
+         *
+         * @author Xeno
+         * @version 1.0.0
+         * @since 2025-09-30
+         * @link https://github.com/xeno-js/xeno-js
+         */
+        maxJitterMs: number;
+    };
+}
+
+/**
+ * Utils that provide utility functions for interacting with the service container and managing scoped service resolution.
+ */
+declare const ContainerUtils: Readonly<{
+    /**
+     * Resolves a scoped service from the container using the provided token.
+     * @param token * The token to resolve from the registry.
+     * @param container * The container to resolve the service from.
+     *
+     * @returns The resolved service instance.
+     * @throws Error if the active service scope is not available.
+     */
+    resolveServiceScoped<K extends keyof T, T extends ApplicationRegistry>(token: K, container: IServiceContainer<T>): T[K];
+    /**
+     * Executes a service action within the context of a scoped service.
+     * @param endpoint * The endpoint to execute the action on.
+     * @param method * The HTTP method to use for the action.
+     * @param headers * The headers to include in the request.
+     * @param transport * The transport object containing the request and response objects.
+     * @param container * The container to resolve the service from.
+     * @param action * The action to execute within the scoped service.
+     *
+     * @returns Promise<ResponseDto<TResponse>> A promise that resolves to the response DTO of the executed action.
+     * @throws Error If the active service scope is not available.
+     * @throws Error If the service is not found in the container.
+     * @throws Error If the service is not a scoped service.
+     */
+    runExecute<TResponse, T extends ApplicationRegistry, TRes, TReq>(endpoint: string, method: Optional<string>, headers: HttpHeaders, transport: {
+        res: TRes;
+        req: TReq;
+    }, container: IServiceContainer<T>, action: () => Promise<ResponseDto<TResponse>>): Promise<ResponseDto<TResponse>>;
+}>;
+
+/**
+ * BaseHandler is an abstract class that implements the IHandler interface.
+ * It provides a base implementation for handling requests and executing strategies.
+ *
+ * @author Xeno
+ * @version 1.0.0
+ * @since 2025-09-30
+ * @link https://github.com/xeno-js/xeno-js
+ */
+declare abstract class BaseHandler<TRequest extends IRequest<TResponse>, TResponse> implements IHandler<TRequest, TResponse> {
+    private readonly _identityFactory;
+    constructor(_identityFactory: IFactory<void, UserContext>);
+    handle(request: TRequest, signal: AbortSignal): Promise<ResultType<TResponse>>;
+    /**
+     * Executes the strategy for the given request.
+     * @param request - The request to be handled.
+     * @param signal - (Optional) The abort signal for the request.
+     * @throws {AppError} If the strategy execution fails.
+     * @protected - This method should be overridden by subclasses.
+     * @abstract - This method must be implemented by subclasses.
+     * @async - This method is asynchronous.
+     * @template TRequest - The type of the request.
+     * @template TResponse - The type of the response.
+     * @returns {Promise<ResultType<TResponse>>} A promise that resolves to the result of the strategy execution.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    protected abstract executeAsync(request: TRequest, signal?: Optional<AbortSignal>): Promise<ResultType<TResponse>>;
+    /**
+     * Gets the current context.
+     * @returns {UserContext} The current context.
+     * {@link UserContext}
+     */
+    protected _getCurrentContext(): UserContext;
+}
+
+/**
+ * @description Abstract base class for authorization strategies in the CQRS pipeline. This class implements the IStrategy interface and provides a common structure for performing authorization checks based on the identity of the authenticated user. It defines an abstract method performAuthorizationCheck that must be implemented by concrete authorization strategies to specify the logic for checking if the user has the necessary permissions to execute a given request. The execute method retrieves the user's identity from the request context and ensures that the user is authenticated before delegating to the performAuthorizationCheck method for further authorization validation. If the user is not authenticated, it returns a failed Result with an appropriate AppError indicating that authentication is required.
+ *
+ * @author Xeno
+ * @version 1.0.0
+ * @since 2025-09-30
+ * @link https://github.com/xeno-js/xeno-js
+ */
+declare abstract class BaseAuthorizationStrategy<TInput extends IRequest> implements IStrategy<TInput> {
+    private readonly _requestContext;
+    /**
+     * @description Constructs a new instance of the BaseAuthorizationStrategy class, which serves as an abstract base for specific authorization strategies in the CQRS pipeline. It takes an IRequestContext as a parameter, which is used to retrieve the identity of the currently authenticated user during the authorization process. This context is essential for performing the authorization checks based on the user's identity when executing requests that require specific permissions.
+     * @param requestContext An instance of IRequestContext used to access the identity of the currently authenticated user. This context is essential for performing the authorization checks based on the user's identity when executing requests that require specific permissions.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    constructor(_requestContext: IContextAccessor<RequestContext>);
+    execute(request: IRequest): Promise<ResultType<void>>;
+    /**
+     * @description Abstract method that must be implemented by concrete authorization strategies to perform the actual authorization check. This method is called after the user's identity has been retrieved and verified. It receives the request and the user's identity as parameters and should return a Result indicating whether the authorization check passed or failed.
+     * @param request The incoming request for which the authorization check is being performed. This request contains information about the action being attempted and any relevant data needed for the authorization logic.
+     * @param auth The identity of the currently authenticated user, which includes information such as the user's ID, tenant ID, and roles. This context is used to determine if the user has the necessary permissions to execute the request.
+     * @returns A Result indicating the outcome of the authorization check. If the check passes, it should return a successful Result with a void value. If the check fails, it should return a failed Result with an appropriate AppError describing the reason for the failure.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    protected abstract performAuthorizationCheck(request: IRequest, auth: Identity): Promise<ResultType<void>>;
+}
+
+/**
+ * Base class for specifications, providing default implementations for logical operations (AND, OR, NOT).
+ *
+ * @template T - The type of the candidate object that the specification will evaluate.
+
+   *
+   * @author Xeno
+   * @version 1.0.0
+   * @since 2025-09-30
+   * @link https://github.com/xeno-js/xeno-js
+   */
+declare abstract class Specification<T> implements ISpecification<T> {
+    /**
+     * Determines if the candidate satisfies the specification criteria.
+     *
+     * @param candidate - The object to evaluate against the specification.
+     * @returns A boolean indicating whether the candidate satisfies the specification.
+    
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    abstract isSatisfiedBy(candidate: T): boolean;
+    /**
+     * Combines this specification with another specification using a logical AND operation.
+     *
+     * @param other - Another specification to combine with this specification.
+     * @returns A new specification that represents the logical AND of this and the other specification.
+    
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    and(other: ISpecification<T>): ISpecification<T>;
+    /**
+     * Combines this specification with another specification using a logical OR operation.
+     *
+     * @param other - Another specification to combine with this specification.
+     * @returns A new specification that represents the logical OR of this and the other specification.
+    
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    or(other: ISpecification<T>): ISpecification<T>;
+    /**
+     * Inverts this specification using a logical NOT operation.
+     *
+     * @returns A new specification that represents the logical NOT of this specification.
+    
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    not(): ISpecification<T>;
+}
+
+/**
+ * @description Type definition for the database context used in the application.
+ * Polymorphically handles both PostgreSQL and libSQL (SQLite/Turso) engines.
+ *
+ * @author Xeno
+ * @version 1.0.0
+ * @since 2025-09-30
+ * @link https://github.com/xeno-js/xeno-js
+ */
+type DbContext<TSchema extends Dictionary = Dictionary> = NodePgDatabase<TSchema> | (LibSQLDatabase<TSchema> & {
+    $client: Client;
+});
+/**
+ * @description Type definition for the transaction object used in the database context.
+ * Polymorphically handles both PostgreSQL and libSQL (SQLite/Turso) engines.
+ *
+ * @author Xeno
+ * @version 1.0.0
+ * @since 2025-09-30
+ * @link https://github.com/xeno-js/xeno-js
+ */
+type DbTransaction = Parameters<Parameters<DbContext['transaction']>[0]>[0];
+
+/**
+ * @description The XenoRegistry type is an alias for the ApplicationRegistry specialized with DbContext. It represents the registry of application services and dependencies, specifically tailored for applications that utilize a database context. This type is used throughout the application to ensure consistent typing and to facilitate dependency injection and service resolution.
+ * @author Xeno
+ * @version 1.0.0
+ * @since 2025-09-30
+ * @link https://github.com/xeno-js/xeno-js
+ */
+type XenoRegistry<TSchema extends Dictionary = Dictionary, TExtensions = object> = ApplicationRegistry<DbContext<TSchema>, DbTransaction> & Readonly<Omit<TExtensions, keyof ApplicationRegistry<DbContext, DbTransaction>>>;
+
+/**
+ * @description The AppBuilder class provides a fluent, .NET-style API for configuring and bootstrapping the application.
+ * It orchestrates the registration of various modules (CQRS, HTTP, Database, Logging, Auth) into the ServiceContainer.
+
+   *
+   * @author Xeno
+   * @version 1.0.0
+   * @since 2025-09-30
+   * @link https://github.com/xeno-js/xeno-js
+   */
+declare class AppBuilder<TRegistry extends XenoRegistry = XenoRegistry> {
+    private readonly _container;
+    private readonly _configuration;
+    constructor(container?: IServiceContainer<TRegistry>);
+    private readonly _modules;
+    private _pipelineConfig;
+    private _config;
+    private _middlewareConfig;
+    private readonly _httpConfig;
+    private _isContextModuleQueued;
+    private _isMiddlewareModuleQueued;
+    private _isPipelineModuleQueued;
+    private _isLoggerModuleQueued;
+    private _isAuthModuleQueued;
+    private _isDbContextModuleQueued;
+    private _isConcurrencyServiceQueued;
+    private _isCacheModuleQueued;
+    /**
+     * @description Enables the use of middlewares in the application. Middlewares can be used for cross-cutting concerns such as logging, authentication, and request/response manipulation.
+     * @returns The current instance of AppBuilder for method chaining.
+    
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    addMiddlewares(setupAction: SetupAction<MiddlewareConfig, IConfigurationService>): this;
+    /**
+     * @description Enables the use of context in the application. Context can be used to store and manage request-specific data, such as user information, correlation IDs, and other metadata that needs to be accessible throughout the request lifecycle.
+     * @returns The current instance of AppBuilder for method chaining.
+    
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    addContext(): this;
+    /**
+     * @description Configures the logger for the application. This method allows you to set up logging options such as log level, console logging, and integration with external logging services like Sentry or Pino.
+     * @param setupAction A callback function that receives a LoggerConfig object to configure the logger settings.
+     * @returns The current instance of AppBuilder for method chaining.
+    
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    addLogger(setupAction?: SetupAction<LoggerConfig<TRegistry>, IConfigurationService>): this;
+    /**
+     * @description Configures the caching settings for the application. This method allows you to set up caching options such as Redis configuration or in-memory caching.
+     * @param setupAction A callback function that receives a CacheConfig object to configure the caching settings.
+     * @returns The current instance of AppBuilder for method chaining.
+    
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    addCache(setupAction?: SetupAction<CacheConfig, IConfigurationService>): this;
+    /**
+     * @description Configures the authentication client for the application. This method allows you to set up authentication options such as the authentication server URL, API key, and additional options.
+     * @param setupAction A callback function that receives an AuthClientConfig object to configure the authentication client settings.
+     * @returns The current instance of AppBuilder for method chaining.
+    
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    addAuth(setupAction: SetupAction<AuthSsrConfig<SupabaseClientOptions<'public'>>, IConfigurationService>): this;
+    /**
+     * @description Configures the database settings for the application. This method allows you to set up database options such as enabling/disabling the database, connection string, and table definitions.
+     * @param setupAction A callback function that receives a DbConfig object to configure the database settings.
+     * @returns The current instance of AppBuilder for method chaining.
+    
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    addDb(setupAction: SetupAction<DbConfig, IConfigurationService>): this;
+    /**
+     * @description Enables the use of the service for concurrency control in the application. This method allows you to limit the number of concurrent asynchronous tasks being executed, which is useful for managing system resources and preventing event loop blocking during massive batch operations.
+     * @returns The current instance of AppBuilder for method chaining.
+    
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    addConcurrencyService(): this;
+    /**
+     * @description Configures the CQRS pipeline settings for the application. This method allows you to set up various aspects of the CQRS pipeline, including performance monitoring, authorization, validation, command bus settings, and query bus settings.
+     * @param setupAction A callback function that receives a PipelineConfig object to configure the CQRS pipeline settings.
+     * @returns The current instance of AppBuilder for method chaining.
+    
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    addPipeline(setupAction?: SetupAction<PipelineConfig<TRegistry>, IConfigurationService>): this;
+    /**
+     * @description Configures the HTTP core settings for the application. This method allows you to set up HTTP core options such as data source token, HTTP client configuration, and resilience settings.
+     * @param setupAction A callback function that receives an HttpCoreConfig object to configure the HTTP core settings.
+     * @returns The current instance of AppBuilder for method chaining.
+    
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    addHttpCore(setupAction: SetupAction<HttpCoreConfig<TRegistry>, IConfigurationService>): this;
+    addAllowOrigin(setupAction: SetupAction<string[], IConfigurationService>): this;
+    /**
+     * @description Registers services in the application. This method allows you to add custom services to the dependency injection container, enabling modular and organized configuration of services.
+     * @param setupAction A callback function that receives the IServiceContainer to register services.
+     * @returns The current instance of AppBuilder for method chaining.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    addServices(setupAction: SetupAction<IServiceContainer<TRegistry>, IConfigurationService>): this;
+    /**
+     * @description Registers a module in the application. A module is a self-contained unit of functionality that can configure services and dependencies in the service container. This method allows you to add custom modules to the application, enabling modular and organized configuration of services.
+     * @param factory A factory function that creates the module instance.
+     * @param opts Optional configuration options for the module.
+     * @returns The current instance of AppBuilder for method chaining.
+     *
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    addModule<T>(name: string, factory: () => Promise<IModule<TRegistry, T>>, opts?: T): this;
+    /**
+     * @description Resolves a service from the dependency injection container.
+     * @param token The injection token used to identify the service.
+     * @returns The resolved service instance.
+    
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    resolve<K extends keyof TRegistry>(token: K): TRegistry[K];
+    /**
+     * @description Finalizes the configuration and initializes all registered modules in the container.
+     * @returns The fully configured ServiceContainer.
+    
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    build(): Promise<IServiceContainer<TRegistry>>;
+    /**
+     * @description Queues the configuration of the CQRS pipeline module if it has not already been queued. This method ensures that the pipeline module is only added once, even if multiple pipeline-related configurations are made.
+    
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    private _queuePipelineModule;
+    /**
+     * @description Queues the configuration of the middleware module if it has not already been queued. This method ensures that the middleware module is only added once, even if multiple middleware-related configurations are made.
+    
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    private _queueMiddlewareModule;
+    /**
+     * @description Queues the configuration of the context module if it has not already been queued. This method ensures that the context module is only added once, even if multiple context-related configurations are made.
+    
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    private _queueContextModule;
+}
+
+interface SupabaseServerAuthFactoryInput<TRegistry extends XenoRegistry> {
+    config: AuthSsrConfig<SupabaseClientOptions<'public'>>;
+    container: IServiceContainer<TRegistry>;
+}
+declare class SupabaseServerAuthFactory<TRegistry extends XenoRegistry = XenoRegistry> implements IFactory<SupabaseServerAuthFactoryInput<TRegistry>, IExtendendService> {
+    create({ config, container, }: SupabaseServerAuthFactoryInput<TRegistry>): IExtendendService;
+}
+
+/**
+ * An abstract generic read-only DAO that provides basic read operations for entities of type T, using a Data Transfer Object (DTO) of type TDto for data access. This class relies on an IReadDataSource to perform database operations and an IMapper to convert between entities and DTOs.
+ * @template T - The type of the entity that the DAO will manage.
+ * @template TDto - The type of the Data Transfer Object (DTO) used for data access.
+
+   *
+   * @author Xeno
+   * @version 1.0.0
+   * @since 2025-09-30
+   * @link https://github.com/xeno-js/xeno-js
+   */
+declare abstract class ReadDao<T, TDto> implements IReadDao<T> {
+    private readonly _dataSource;
+    private readonly _mapper;
+    /**
+     * Constructs a new ReadDao instance.
+     * @param _dataSource An instance of IReadDataSource used to execute SQL queries and commands for data access.
+     * @param _mapper An instance of IMapper used to convert between entities and DTOs.
+     *
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    constructor(_dataSource: IReadDataSource<TDto>, _mapper: IMapper<T, TDto>);
+    findById(id: string | number, ctx: UserContext, signal: Optional<AbortSignal>): Promise<ResultType<Optional<T>>>;
+    findAll(ctx: UserContext, signal: Optional<AbortSignal>): Promise<ResultType<T[]>>;
+}
+
+/**
+ * An abstract generic repository that provides basic CRUD operations for entities of type T, using a Data Transfer Object (DTO) of type TDto for data access. This class relies on an IWriteDataSource to perform database operations and an IMapper to convert between entities and DTOs.
+ * @template T - The type of the entity that the repository will manage.
+ * @template TDto - The type of the Data Transfer Object (DTO) used for data access.
+
+   *
+   * @author Xeno
+   * @version 1.0.0
+   * @since 2025-09-30
+   * @link https://github.com/xeno-js/xeno-js
+   */
+declare abstract class Repository<T, TDto> implements IRepository<T> {
+    private readonly _dataSource;
+    private readonly _mapper;
+    /**
+     * Constructs a new Repository instance.
+     * @param _dataSource An instance of IWriteDataSource used to execute SQL queries and commands for data access.
+     * @param _mapper An instance of IMapper used to convert between entities and DTOs.
+     *
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    constructor(_dataSource: IWriteDataSource<TDto>, _mapper: IMapper<T, TDto>);
+    findById(id: string | number, ctx: UserContext, signal: Optional<AbortSignal>): Promise<ResultType<Optional<T>>>;
+    findAll(ctx: UserContext, signal: Optional<AbortSignal>): Promise<ResultType<T[]>>;
+    save(entity: T, signal: Optional<AbortSignal>): Promise<ResultType<void>>;
+    delete(entity: T, ctx: UserContext, signal: Optional<AbortSignal>): Promise<ResultType<void>>;
+    update(id: string | number, entity: Partial<T>, ctx: UserContext, signal: Optional<AbortSignal>): Promise<ResultType<void>>;
+}
+
+/**
+ * BaseController is an abstract class that implements the IController interface. It provides a foundation for creating specific controllers that handle incoming requests and return responses. The class requires a mediator to facilitate communication between different parts of the application.
+ * @template TRequest - The type of the request object that the controller will handle.
+ * @template TResponse - The type of the response object that the controller will return.
+ *
+ * @author Xeno
+ * @version 1.0.0
+ * @since 2025-09-30
+ * @link https://github.com/xeno-js/xeno-js
+ */
+declare abstract class BaseController<TRequest, TResponse> implements IController<TRequest, TResponse> {
+    private readonly _requestContext;
+    private readonly _mediator;
+    /**
+     * Constructs a new instance of the BaseController class.
+     * @param _requestContext - An instance of IContextAccessor used to manage the execution context for requests.
+     * @param _mediator - An instance of IMediator used to facilitate communication between different parts of the application.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    constructor(_requestContext: IContextAccessor<RequestContext>, _mediator: IMediator);
+    abstract handle(request: TRequest): Promise<ResponseDto<TResponse>>;
+    /**
+     * Helper to return a successful 200/201 response.
+     * @param data - The data to include in the response.
+     * @param status - The HTTP status code (default is 200).
+     * @param meta - Optional metadata to include in the response.
+     * @param headers - Optional headers to include in the response.
+     * @returns A ResponseDto containing the data and status.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    protected ok<T>(data: T, status?: number, meta?: Optional<Dictionary>, headers?: Optional<Dictionary<string[]>>): ResponseDto<T>;
+    /**
+     * Helper to automatically map a failed Result (from the CQRS pipeline)
+     * into a standardized ErrorResponseDto.
+     * @param error - The AppError instance representing the error.
+     * @param details - Optional additional details about the error.
+     * @param headers - Optional headers to include in the error response.
+     * @returns A ResponseDto representing the error response.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    protected fail(error: AppError, details?: Optional<string>, headers?: Optional<Dictionary<string[]>>): ResponseDto<TResponse>;
+    /**
+     * Helper to send a query through the mediator and return the result.
+     * @param request - The IQuery instance to be sent.
+     * @returns A promise resolving to the result of the query.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    protected _query(request: IQuery<TResponse>): Promise<ResultType<TResponse>>;
+    /**
+     * Helper to send a command through the mediator and return the result.
+     * @param request - The ICommand instance to be sent.
+     * @returns A promise resolving to the result of the command.
+     *
+     * @author Xeno
+     * @version 1.0.0
+     * @since 2025-09-30
+     * @link https://github.com/xeno-js/xeno-js
+     */
+    protected _send(request: ICommand<TResponse>): Promise<ResultType<TResponse>>;
+    protected getContext(): Optional<RequestContext>;
+}
+
+export { AppBuilder, type ApplicationRegistry, type AuthSsrConfig, BaseAuthorizationStrategy, BaseController, BaseHandler, ContainerUtils, type DbContext, type DbTransaction, type ExecutionContext, type HttpConfig, type HttpCoreConfig, type IAllowMethod, type IAllowOrigin, type IModule, type IRequestContext, type IServiceContainer, type IServiceProvider, type IServiceScope, type IServiceScopeAccessor, type ISsrCookie, type ISsrCookieHandler, type ISsrCookieToSet, type Lifetime, type LoggerConfig, type MiddlewareConfig, type PinoLoggerConfig, type PipelineConfig, ReadDao, Repository, type ResilienceConfig, type SchemaConfig, type SentryLoggerConfig, type ServiceDescriptor, Specification, SupabaseServerAuthFactory, type XenoRegistry };