alepha 0.9.2 → 0.9.4

package/core.d.ts

@@ -14,7 +14,14 @@ import { ReadableStream as ReadableStream$1 } from "node:stream/web";
  * @internal
  */
 declare const KIND: unique symbol;
-//# sourceMappingURL=KIND.d.ts.map
+//#endregion
+//#region src/constants/MODULE.d.ts
+/**
+ * Used for identifying modules.
+ *
+ * @internal
+ */
+declare const MODULE: unique symbol;
 //#endregion
 //#region src/interfaces/Service.d.ts
 /**
@@ -61,15 +68,8 @@ interface ServiceSubstitution<T extends object = any> {
  * And yes, you declare the *type* of the service, not the *instance*.
  */
 type ServiceEntry<T extends object = any> = Service<T> | ServiceSubstitution<T>;
-//# sourceMappingURL=Service.d.ts.map
 //#endregion
 //#region src/helpers/descriptor.d.ts
-declare const descriptorEvents: {
-  events: Map<Service, ((alepha: Alepha) => void)[]>;
-  on(descriptor: Service, callback: (alepha: Alepha) => void): void;
-  emit(descriptor: Service, alepha: Alepha): void;
-  bind(when: Service, register: Service): void;
-};
 interface DescriptorArgs<T extends object = {}> {
   options: T;
   alepha: Alepha;
@@ -99,20 +99,112 @@ type DescriptorFactoryLike<T extends object = any> = {
   (options: T): any;
   [KIND]: any;
 };
-declare const createDescriptor: <TDescriptor extends Descriptor>(descriptor: InstantiableClass<TDescriptor>, options: TDescriptor["options"]) => TDescriptor;
-//# sourceMappingURL=descriptor.d.ts.map
+declare const createDescriptor: <TDescriptor extends Descriptor>(descriptor: InstantiableClass<TDescriptor> & {
+  [MODULE]?: Service;
+}, options: TDescriptor["options"]) => TDescriptor;
 //#endregion
-//#region src/helpers/Module.d.ts
-interface Module {
-  $name?: string;
-  $services: (alepha: Alepha) => void | Alepha;
+//#region src/descriptors/$inject.d.ts
+/**
+ * Get the instance of the specified type from the context.
+ *
+ * ```ts
+ * class A { }
+ * class B {
+ *   a = $inject(A);
+ * }
+ * ```
+ */
+declare const $inject: <T extends object>(type: Service<T>, opts?: InjectOptions<T>) => T;
+declare class InjectDescriptor extends Descriptor {}
+interface InjectOptions<T extends object = any> {
+  /**
+   * Ignore current existing instance.
+   */
+  skipCache?: boolean;
+  /**
+   * Don't store the instance in the registry.
+   */
+  skipRegistration?: boolean;
+  /**
+   * Constructor arguments to pass when creating a new instance.
+   */
+  args?: ConstructorParameters<InstantiableClass<T>>;
+  /**
+   * Parent service that requested the instance.
+   * @internal
+   */
+  parent?: Service | null;
+}
+//#endregion
+//#region src/constants/OPTIONS.d.ts
+/**
+ * Used for descriptors options.
+ *
+ * @internal
+ */
+declare const OPTIONS: unique symbol;
+//#endregion
+//#region src/descriptors/$module.d.ts
+/**
+ * Wrap services and descriptors into a module.
+ *
+ * Module is just a class.
+ * You must attach a `name` to it.
+ *
+ * It's recommended to use `project.module.submodule` format.
+ *
+ * @example
+ * ```ts
+ * import { $module } from "alepha";
+ * import { MyService } from "./MyService.ts";
+ *
+ * // export MyService so it can be used everywhere
+ * export * from "./MyService.ts";
+ *
+ * export default $module({
+ *  name: "my.project.module",
+ *  // MyService will have a module context "my.project.module"
+ *  services: [MyService],
+ * });
+ * ```
+ *
+ * - Module is used for logging and other purposes.
+ * - It's useful for large applications or libraries to group services and descriptors together.
+ * - It's probably overkill for small applications.
+ */
+declare const $module: (options: ModuleDescriptorOptions) => Service<Module>;
+interface ModuleDescriptorOptions {
+  /**
+   * Name of the module.
+   *
+   * It should be in the format of `project.module.submodule`.
+   */
+  name: string;
+  /**
+   * List of services to register in the module.
+   */
+  services?: Array<Service>;
+  /**
+   * List of $descriptors to register in the module.
+   */
+  descriptors?: Array<DescriptorFactoryLike>;
+  /**
+   * By default, module will register all services.
+   * You can override this behavior by providing a register function.
+   * It's useful when you want to register services conditionally or in a specific order.
+   */
+  register?: (alepha: Alepha) => void;
 }
-interface ModuleDefinition extends Module {
-  services: Array<Service>;
+interface Module {
+  [KIND]: "MODULE";
+  [OPTIONS]: ModuleDescriptorOptions;
+  register: (alepha: Alepha) => void;
 }
+type ServiceWithModule<T extends object = any> = T & {
+  [MODULE]?: Service;
+};
 declare const isModule: (value: unknown) => value is Module;
 declare const toModuleName: (name: string) => string;
-//# sourceMappingURL=Module.d.ts.map
 //#endregion
 //#region src/interfaces/Async.d.ts
 /**
@@ -127,13 +219,22 @@ type AsyncFn = (...args: any[]) => Async<any>;
  * Transforms a type T into a promise if it is not already a promise.
  */
 type MaybePromise<T> = T extends Promise<any> ? T : Promise<T>;
-//# sourceMappingURL=Async.d.ts.map
+//#endregion
+//#region src/interfaces/LoggerInterface.d.ts
+type LogLevel = "error" | "warn" | "info" | "debug" | "trace" | "silent";
+interface LoggerInterface {
+  trace(message: string, data?: unknown): void;
+  debug(message: string, data?: unknown): void;
+  info(message: string, data?: unknown): void;
+  warn(message: string, data?: unknown): void;
+  error(message: string, data?: unknown): void;
+}
 //#endregion
 //#region src/providers/AlsProvider.d.ts
 type AsyncLocalStorageData = any;
 declare class AlsProvider {
   static create: () => AsyncLocalStorage<AsyncLocalStorageData> | undefined;
-  protected als?: AsyncLocalStorage<AsyncLocalStorageData>;
+  als?: AsyncLocalStorage<AsyncLocalStorageData>;
   constructor();
   createContextId(): string;
   run<R>(callback: () => R, data?: Record<string, any>): R;
@@ -141,150 +242,6 @@ declare class AlsProvider {
   get<T>(key: string): T | undefined;
   set<T>(key: string, value: T): void;
 }
-//# sourceMappingURL=AlsProvider.d.ts.map
-//#endregion
-//#region src/services/Logger.d.ts
-type LogLevel = "error" | "warn" | "info" | "debug" | "trace" | "silent";
-interface LoggerEnv {
-  /**
-   * Default log level for the application.
-   * Default by environment:
-   * - dev = "debug"
-   * - test = "error"
-   * - prod = "info"
-   *
-   * "trace" | "debug" | "info" | "warn" | "error" | "silent"
-   */
-  LOG_LEVEL?: string;
-  /**
-   * Disable colors in the console output.
-   */
-  NO_COLOR?: string;
-  /**
-   * Force color output for the application.
-   */
-  FORCE_COLOR?: string;
-  /**
-   * Log format.
-   *
-   * @default "text"
-   */
-  LOG_FORMAT?: "json" | "text" | "cli" | "raw";
-}
-interface LoggerOptions {
-  /**
-   * The logging level. Can be one of "error", "warn", "info", "debug", or "trace".
-   */
-  level?: string;
-  /**
-   * The name of the application. Used to identify the source of the log messages.
-   */
-  app?: string;
-  /**
-   * The name of the logger. Like a module name or a service name.
-   */
-  name?: string;
-  /**
-   * An optional context to include in the log output. Like a request ID or a correlation ID.
-   */
-  context?: string;
-  /**
-   * An optional tag to include in the log output. Like a class name or a module name.
-   */
-  caller?: string;
-  /**
-   * Whether to use colors in the log output. Defaults to true.
-   */
-  color?: boolean;
-  /**
-   * Log output format. Can be "json", "text", or "cli".
-   */
-  format?: string;
-  /**
-   * An optional async local storage provider to use for storing context information.
-   */
-  als?: AlsProvider;
-}
-declare const COLORS: {
-  reset: string;
-  grey: string;
-  red: string;
-  orange: string;
-  green: string;
-  blue: string;
-  white: string;
-  cyan: string;
-  darkGrey: string;
-};
-declare const LEVEL_COLORS: Record<string, string>;
-declare class Logger {
-  protected levelOrder: Record<string, number>;
-  readonly level: string;
-  readonly rawLevel: string;
-  readonly name: string;
-  protected caller: string;
-  protected context: string;
-  protected app: string;
-  protected color: boolean;
-  protected format: string;
-  protected als?: AlsProvider;
-  constructor(options?: LoggerOptions);
-  parseLevel(level: string, app: string): LogLevel;
-  asLogLevel(something: string): LogLevel;
-  child(options: LoggerOptions): Logger;
-  error(message: unknown, data?: object | Error | string | unknown): void;
-  warn(message: unknown, data?: object | Error | string): void;
-  info(message: unknown, data?: object | Error | string): void;
-  debug(message: unknown, data?: object | Error | string): void;
-  trace(message: unknown, data?: object | Error | string): void;
-  /**
-   * Log a message to the console.
-   */
-  protected log(level: LogLevel, message: unknown, data?: object | Error | string): void;
-  /**
-   * Print a log message to the console.
-   */
-  protected print(formatted: string): void;
-  /**
-   * Format a log message to JSON.
-   */
-  protected formatJson(level: LogLevel, message: unknown, data?: object | Error | string): string;
-  protected formatJsonError(error: Error): object;
-  /**
-   * Format a log message to a string.
-   */
-  protected formatLog(level: LogLevel, message: string, data?: object | Error): string;
-  protected nowTimeFormatted(): string;
-  protected pad2: (n: number) => string;
-  protected pad3: (n: number) => string;
-  protected colorize(color: string, text: string, reset?: string): string;
-  /**
-   * Format an error to a string.
-   *
-   * @param error
-   * @protected
-   */
-  protected formatError(error: Error): string;
-}
-declare class MockLogger extends Logger {
-  store: MockLoggerStore;
-  constructor(options?: LoggerOptions & {
-    store: MockLoggerStore;
-  });
-  print(msg: string): void;
-  child(options: LoggerOptions): MockLogger;
-  reset(): void;
-}
-interface MockLoggerStore {
-  stack: Array<{
-    date: string;
-    level: string;
-    message: string;
-    context?: string;
-    app?: string;
-  } & Record<string, any>>;
-}
-//# sourceMappingURL=Logger.d.ts.map
 //#endregion
 //#region src/Alepha.d.ts
 /**
@@ -385,7 +342,7 @@ interface MockLoggerStore {
  * 	 onCustomerHook = $hook({
  * 			on: "my:custom:hook",
  * 			handler: () => {
- * 		 	  this.log.info("App is being configured");
+ * 		 	  this.log?.info("App is being configured");
  * 	 		},
  * 	  });
  * 	}
@@ -495,10 +452,9 @@ declare class Alepha {
    *
    * Modules are used to group services and provide a way to register them in the container.
    */
-  protected modules: Array<ModuleDefinition>;
+  protected modules: Array<Module>;
   protected substitutions: Map<Service, {
     use: Service;
-    module?: ModuleDefinition;
   }>;
   protected configurations: Map<Service, object>;
   protected descriptorRegistry: Map<Service<Descriptor<{}>>, Descriptor<{}>[]>;
@@ -513,7 +469,7 @@ declare class Alepha {
   /**
    * Get logger instance.
    */
-  get log(): Logger;
+  get log(): LoggerInterface | undefined;
   /**
    * The environment variables for the App.
    */
@@ -649,31 +605,7 @@ declare class Alepha {
    *
    * @return The instance of the specified class or type.
    */
-  inject<T extends object>(service: Service<T>, opts?: {
-    /**
-     * Ignore current existing instance.
-     */
-    skipCache?: boolean;
-    /**
-     * Don't store the instance in the registry.
-     */
-    skipRegistration?: boolean;
-    /**
-     * Constructor arguments to pass when creating a new instance.
-     */
-    args?: ConstructorParameters<InstantiableClass<T>>;
-    /**
-     * Parent service that requested the instance.
-     * @internal
-     */
-    parent?: Service | null;
-    /**
-     * If the service is provided by a module, the module definition.
-     * @internal
-     */
-    module?: ModuleDefinition;
-  }): T;
-  protected pushModule(instance: Module): void;
+  inject<T extends object>(service: Service<T>, opts?: InjectOptions<T>): T;
   /**
    * Configures the specified service with the provided state.
    * If service is not registered, it will do nothing.
@@ -774,14 +706,10 @@ declare class Alepha {
     module?: string;
   }>;
   descriptors<TDescriptor extends Descriptor>(factory: {
-    [KIND]: InstantiableClass<TDescriptor> | string;
-  }): Array<TDescriptor>;
-  protected new<T extends object>(service: Service<T>, args?: any[], module?: ModuleDefinition): T;
+    [KIND]: InstantiableClass<TDescriptor>;
+  } | string): Array<TDescriptor>;
+  protected new<T extends object>(service: Service<T>, args?: any[]): T;
   protected processDescriptor(value: Descriptor, propertyKey?: string): void;
-  /**
-   * @internal
-   */
-  protected createLogger(env: Env): Logger;
 }
 interface Hook<T extends keyof Hooks = any> {
   caller?: Service;
@@ -804,9 +732,9 @@ interface ServiceDefinition<T extends object = any> {
   /**
    * If the service is provided by a module, the module definition.
    */
-  module?: ModuleDefinition;
+  module?: Service;
 }
-interface Env extends LoggerEnv {
+interface Env {
   [key: string]: string | boolean | number | undefined;
   /**
    * Optional environment variable that indicates the current environment.
@@ -822,7 +750,7 @@ interface Env extends LoggerEnv {
   MODULE_NAME?: string;
 }
 interface State {
-  log: Logger;
+  log?: LoggerInterface;
   env?: Readonly<Env>;
   /**
    * If defined, the Alepha container will only register this service and its dependencies.
@@ -899,17 +827,16 @@ interface RunOptions {
    */
   cluster?: boolean;
 }
-//# sourceMappingURL=Run.d.ts.map
 //#endregion
-//#region src/constants/OPTIONS.d.ts
+//#region src/constants/PRIMITIVE.d.ts
 /**
- * Used for descriptors options.
+ * Symbol to mark a value as a primitive.
+ *
+ * Used to enhance TypeBox types with metadata. See @alepha/protobuf.
  *
  * @internal
  */
-declare const OPTIONS: unique symbol;
-//# sourceMappingURL=OPTIONS.d.ts.map
-
+declare const PRIMITIVE: unique symbol;
 //#endregion
 //#region src/descriptors/$cursor.d.ts
 /**
@@ -943,12 +870,10 @@ declare const $cursor: () => CursorDescriptor;
  */
 declare const __alephaRef: {
   context?: Alepha;
-  definition?: Service;
-  module?: ModuleDefinition;
-  $services?: {
-    module: ModuleDefinition;
-    parent: Service;
+  definition?: Service & {
+    [MODULE]?: Service;
   };
+  parent?: Service;
 };
 /**
  * Cursor descriptor.
@@ -956,9 +881,8 @@ declare const __alephaRef: {
 interface CursorDescriptor {
   context: Alepha;
   definition?: Service;
-  module?: ModuleDefinition;
+  module?: Service;
 }
-//# sourceMappingURL=$cursor.d.ts.map
 //#endregion
 //#region src/descriptors/$env.d.ts
 /**
@@ -988,8 +912,6 @@ interface CursorDescriptor {
  * ```
  */
 declare const $env: <T extends TObject$1>(type: T) => Static$1<T>;
-//# sourceMappingURL=$env.d.ts.map
-
 //#endregion
 //#region src/descriptors/$hook.d.ts
 /**
@@ -1043,7 +965,7 @@ interface HookOptions<T extends keyof Hooks> {
   /**
    * The handler to run when the hook is triggered.
    */
-  handler: (app: Hooks[T]) => Async<any>;
+  handler: (args: Hooks[T]) => Async<any>;
   /**
    * Force the hook to run first or last on the list of hooks.
    */
@@ -1061,152 +983,81 @@ declare class HookDescriptor<T extends keyof Hooks> extends Descriptor<HookOptio
   called: number;
   protected onInit(): void;
 }
-//# sourceMappingURL=$hook.d.ts.map
-//#endregion
-//#region src/descriptors/$inject.d.ts
-/**
- * Get the instance of the specified type from the context.
- *
- * ```ts
- * class A { }
- * class B {
- *   a = $inject(A);
- * }
- * ```
- */
-declare const $inject: <T extends object>(type: Service<T>) => T;
-declare class InjectDescriptor extends Descriptor {}
-//# sourceMappingURL=$inject.d.ts.map
-
-//#endregion
-//#region src/descriptors/$logger.d.ts
-/**
- * Create a logger.
- *
- * `name` is optional, by default it will use the name of the service.
- *
- * @example
- * ```ts
- * import { $logger } from "alepha";
- *
- * class MyService {
- * 	log = $logger();
- *
- * 	constructor() {
- * 	    // print something like 'date - [MyService] Service initialized'
- * 		this.log.info("Service initialized");
- * 	}
- * }
- * ```
- */
-declare const $logger: {
-  (options?: LoggerDescriptorOptions): Logger;
-  [KIND]: typeof Logger;
-};
-interface LoggerDescriptorOptions {
-  name?: string;
-}
-//# sourceMappingURL=$logger.d.ts.map
-
-//#endregion
-//#region src/descriptors/$module.d.ts
-/**
- * Wrap services and descriptors into a module.
- *
- * Module is just a class.
- * You must attach a `name` to it.
- *
- * It's recommended to use `project.module.submodule` format.
- *
- * @example
- * ```ts
- * import { $module } from "alepha";
- * import { MyService } from "./MyService.ts";
- *
- * // export MyService so it can be used everywhere
- * export * from "./MyService.ts";
- *
- * export default $module({
- *  name: "my.project.module",
- *  // MyService will have a module context "my.project.module"
- *  services: [MyService],
- * });
- * ```
- *
- * - Module is used for logging and other purposes.
- * - It's useful for large applications or libraries to group services and descriptors together.
- * - It's probably overkill for small applications.
- */
-declare const $module: (args: ModuleDescriptorOptions) => ModuleDescriptor;
-type ModuleDescriptor = Service<Module>;
-interface ModuleDescriptorOptions {
-  /**
-   * Name of the module.
-   *
-   * It should be in the format of `project.module.submodule`.
-   */
-  name: string;
-  /**
-   * List of services to register in the module.
-   */
-  services?: Array<ServiceEntry>;
-  /**
-   * List of $descriptors to register in the module.
-   */
-  descriptors?: Array<DescriptorFactoryLike>;
-  /**
-   * By default, module will register all services.
-   * You can override this behavior by providing a register function.
-   * It's useful when you want to register services conditionally or in a specific order.
-   */
-  register?: (alepha: Alepha) => void;
-}
-//# sourceMappingURL=$module.d.ts.map
 //#endregion
 //#region src/errors/AlephaError.d.ts
 /**
  * Default error class for Alepha.
  */
-declare class AlephaError extends Error {}
-//# sourceMappingURL=AlephaError.d.ts.map
+declare class AlephaError extends Error {
+  name: string;
+}
 //#endregion
 //#region src/errors/AppNotStartedError.d.ts
 declare class AppNotStartedError extends Error {
+  readonly name = "AppNotStartedError";
   constructor();
 }
-//# sourceMappingURL=AppNotStartedError.d.ts.map
 //#endregion
 //#region src/errors/CircularDependencyError.d.ts
 declare class CircularDependencyError extends Error {
+  readonly name = "CircularDependencyError";
   constructor(provider: string, parents?: string[]);
 }
-//# sourceMappingURL=CircularDependencyError.d.ts.map
 //#endregion
 //#region src/errors/ContainerLockedError.d.ts
 declare class ContainerLockedError extends Error {
+  readonly name = "ContainerLockedError";
   constructor(message?: string);
 }
-//# sourceMappingURL=ContainerLockedError.d.ts.map
-//#endregion
-//#region src/errors/NotImplementedError.d.ts
-declare class NotImplementedError extends Error {
-  constructor(provider: string);
-}
-//# sourceMappingURL=NotImplementedError.d.ts.map
 //#endregion
 //#region src/errors/TypeBoxError.d.ts
 declare class TypeBoxError extends Error {
+  readonly name = "TypeBoxError";
   readonly value: ValueError;
   constructor(value: ValueError);
 }
-//# sourceMappingURL=TypeBoxError.d.ts.map
-
 //#endregion
 //#region src/providers/TypeProvider.d.ts
 declare class TypeProvider {
-  static DEFAULT_STRING_MAX_LENGTH: number;
-  static DEFAULT_LONG_STRING_MAX_LENGTH: number;
-  static DEFAULT_RICH_STRING_MAX_LENGTH: number;
+  /**
+   * Default maximum length for strings.
+   *
+   * It can be set to a larger value:
+   * ```ts
+   * TypeProvider.DEFAULT_STRING_MAX_LENGTH = 1000000;
+   * TypeProvider.DEFAULT_STRING_MAX_LENGTH = undefined; // no limit (not recommended)
+   * ```
+   */
+  static DEFAULT_STRING_MAX_LENGTH: number | undefined;
+  static DEFAULT_SHORT_STRING_MAX_LENGTH: number | undefined;
+  /**
+   * Maximum length for long strings, such as descriptions or comments.
+   * It can be overridden in the string options.
+   *
+   * It can be set to a larger value:
+   * ```ts
+   * TypeProvider.DEFAULT_LONG_STRING_MAX_LENGTH = 2048;
+   * ```
+   */
+  static DEFAULT_LONG_STRING_MAX_LENGTH: number | undefined;
+  /**
+   * Maximum length for rich strings, such as HTML or Markdown.
+   * This is a large value to accommodate rich text content.
+   * > It's also the maximum length of PG's TEXT type.
+   *
+   * It can be overridden in the string options.
+   *
+   * It can be set to a larger value:
+   * ```ts
+   * TypeProvider.DEFAULT_RICH_STRING_MAX_LENGTH = 1000000;
+   * ```
+   */
+  static DEFAULT_RICH_STRING_MAX_LENGTH: number | undefined;
+  /**
+   * Maximum number of items in an array.
+   * This is a default value to prevent excessive memory usage.
+   * It can be overridden in the array options.
+   */
   static DEFAULT_ARRAY_MAX_ITEMS: number;
   static FormatRegistry: typeof FormatRegistry;
   raw: TypeBox.JavaScriptTypeBuilder;
@@ -1288,7 +1139,7 @@ declare class TypeProvider {
    * Create a schema for a bigint. Bigint is a 64-bit integer.
    * This is a workaround for TypeBox, which does not support bigint natively.
    */
-  bigint(options?: IntegerOptions): TNumber$1;
+  bigint(options?: NumberOptions): TNumber$1;
   /**
    * Make a schema optional.
    *
@@ -1431,7 +1282,6 @@ declare function isISODate(str: string): boolean;
 declare function isISODateTime(value: string): boolean;
 declare function isUUID(value: string): boolean;
 declare function isEmail(value: string): boolean;
-//# sourceMappingURL=TypeProvider.d.ts.map
 //#endregion
 //#region src/index.d.ts
 declare global {
@@ -1446,8 +1296,6 @@ declare global {
  *
  */
 declare const run: (entry: Alepha | Service | Array<Service>, opts?: RunOptions) => void;
-//# sourceMappingURL=index.d.ts.map
-
 //#endregion
-export { $cursor, $env, $hook, $inject, $logger, $module, AbstractClass, Alepha, AlephaError, AlephaStringOptions, AlsProvider, AppNotStartedError, Async, AsyncFn, AsyncLocalStorageData, COLORS, CircularDependencyError, ContainerLockedError, CursorDescriptor, Descriptor, DescriptorArgs, DescriptorConfig, DescriptorFactory, DescriptorFactoryLike, Env, FileLike, Hook, HookDescriptor, HookOptions, Hooks, InjectDescriptor, InstantiableClass, KIND, LEVEL_COLORS, LogLevel, Logger, LoggerDescriptorOptions, LoggerEnv, LoggerOptions, MaybePromise, MockLogger, MockLoggerStore, Module, ModuleDefinition, ModuleDescriptor, ModuleDescriptorOptions, NotImplementedError, OPTIONS, Service, ServiceEntry, ServiceSubstitution, State, type Static, type StaticDecode, type StaticEncode, StreamLike, type TAny, type TArray, type TBoolean, TFile, type TNumber, type TObject, type TOptional, type TProperties, type TRecord, type TSchema, TStream, type TString, TextLength, TypeBox, TypeBoxError, TypeBoxValue, TypeGuard, TypeProvider, __alephaRef, createDescriptor, descriptorEvents, isEmail, isFileLike, isISODate, isISODateTime, isModule, isTypeFile, isTypeStream, isUUID, run, t, toModuleName };
+export { $cursor, $env, $hook, $inject, $module, AbstractClass, Alepha, AlephaError, AlephaStringOptions, AlsProvider, AppNotStartedError, Async, AsyncFn, AsyncLocalStorageData, CircularDependencyError, ContainerLockedError, CursorDescriptor, Descriptor, DescriptorArgs, DescriptorConfig, DescriptorFactory, DescriptorFactoryLike, Env, FileLike, Hook, HookDescriptor, HookOptions, Hooks, InjectDescriptor, InjectOptions, InstantiableClass, KIND, LogLevel, LoggerInterface, MaybePromise, Module, ModuleDescriptorOptions, OPTIONS, PRIMITIVE, Service, ServiceEntry, ServiceSubstitution, ServiceWithModule, State, type Static, type StaticDecode, type StaticEncode, StreamLike, type TAny, type TArray, type TBoolean, TFile, type TNumber, type TObject, type TOptional, type TProperties, type TRecord, type TSchema, TStream, type TString, TextLength, TypeBox, TypeBoxError, TypeBoxValue, TypeGuard, TypeProvider, __alephaRef, createDescriptor, isEmail, isFileLike, isISODate, isISODateTime, isModule, isTypeFile, isTypeStream, isUUID, run, t, toModuleName };
 //# sourceMappingURL=index.d.ts.map