alepha 0.10.7 → 0.11.1

package/core.d.ts

@@ -1,9 +1,9 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import { Validator } from "typebox/compile";
+import * as TypeBoxValue from "typebox/value";
 import * as TypeBox from "typebox";
-import { Static, Static as Static$1, StaticDecode, StaticEncode, TAny, TAny as TAny$1, TArray, TArray as TArray$1, TArrayOptions, TBigInt, TBoolean, TBoolean as TBoolean$1, TInteger, TInteger as TInteger$1, TKeysToIndexer, TNull, TNull as TNull$1, TNumber, TNumber as TNumber$1, TNumberOptions, TNumberOptions as TNumberOptions$1, TObject, TObject as TObject$1, TObjectOptions, TObjectOptions as TObjectOptions$1, TOptional, TOptionalAdd, TOptionalAdd as TOptionalAdd$1, TPick, TProperties, TProperties as TProperties$1, TRecord, TRecord as TRecord$1, TSchema, TSchema as TSchema$1, TSchemaOptions, TString, TString as TString$1, TStringOptions, TStringOptions as TStringOptions$1, TTuple, TUnion, TUnion as TUnion$1, TUnsafe, TVoid } from "typebox";
+import { Static as Static$1, StaticDecode, StaticDecode as Static, StaticDecode as StaticDecode$1, StaticEncode, StaticEncode as StaticEncode$1, TAny, TAny as TAny$1, TArray, TArray as TArray$1, TArrayOptions, TBigInt, TBoolean, TBoolean as TBoolean$1, TInteger, TInteger as TInteger$1, TKeysToIndexer, TKeysToIndexer as TKeysToIndexer$1, TNull, TNull as TNull$1, TNumber, TNumber as TNumber$1, TNumberOptions, TNumberOptions as TNumberOptions$1, TObject, TObject as TObject$1, TObjectOptions, TObjectOptions as TObjectOptions$1, TOmit, TOptional, TOptionalAdd, TOptionalAdd as TOptionalAdd$1, TPick, TPick as TPick$1, TProperties, TProperties as TProperties$1, TRecord, TRecord as TRecord$1, TSchema, TSchema as TSchema$1, TSchemaOptions, TString, TString as TString$1, TStringOptions, TStringOptions as TStringOptions$1, TTuple, TUnion, TUnion as TUnion$1, TUnsafe, TUnsafe as TUnsafe$1, TVoid } from "typebox";
 import TypeBoxFormat from "typebox/format";
-import * as TypeBoxValue from "typebox/value";
 import { Readable } from "node:stream";
 import { ReadableStream as ReadableStream$1 } from "node:stream/web";
 import { TLocalizedValidationError } from "typebox/error";
@@ -28,13 +28,14 @@ declare const MODULE: unique symbol;
 /**
  * In Alepha, a service is a class that can be instantiated or an abstract class. Nothing more, nothing less...
  */
-type Service<T$1 extends object = any> = InstantiableClass<T$1> | AbstractClass<T$1>;
-type InstantiableClass<T$1 extends object = any> = new (...args: any[]) => T$1;
+type Service<T extends object = any> = InstantiableClass<T> | AbstractClass<T> | RunFunction<T>;
+type RunFunction<T extends object = any> = (...args: any[]) => T | void;
+type InstantiableClass<T extends object = any> = new (...args: any[]) => T;
 /**
  * Abstract class is a class that cannot be instantiated directly!
  * It widely used for defining interfaces.
  */
-type AbstractClass<T$1 extends object = any> = abstract new (...args: any[]) => T$1;
+type AbstractClass<T extends object = any> = abstract new (...args: any[]) => T;
 /**
  * Service substitution allows you to register a class as a different class.
  * Providing class A, but using class B instead.
@@ -42,17 +43,17 @@ type AbstractClass<T$1 extends object = any> = abstract new (...args: any[]) =>
  *
  * class A is mostly an AbstractClass, while class B is an InstantiableClass.
  */
-interface ServiceSubstitution<T$1 extends object = any> {
+interface ServiceSubstitution<T extends object = any> {
   /**
    * Every time someone asks for this class, it will be provided with the 'use' class.
    */
-  provide: Service<T$1>;
+  provide: Service<T>;
   /**
    * Service to use instead of the 'provide' service.
    *
    * Syntax is inspired by Angular's DI system.
    */
-  use: Service<T$1>;
+  use: Service<T>;
   /**
    * If true, if the service already exists -> just ignore the substitution and do not throw an error.
    * Mostly used for plugins to enforce a substitution without throwing an error.
@@ -68,11 +69,12 @@ interface ServiceSubstitution<T$1 extends object = any> {
  *
  * And yes, you declare the *type* of the service, not the *instance*.
  */
-type ServiceEntry<T$1 extends object = any> = Service<T$1> | ServiceSubstitution<T$1>;
+type ServiceEntry<T extends object = any> = Service<T> | ServiceSubstitution<T>;
+declare function isClass(func: any): func is InstantiableClass;
 //#endregion
 //#region src/helpers/descriptor.d.ts
-interface DescriptorArgs<T$1 extends object = {}> {
-  options: T$1;
+interface DescriptorArgs<T extends object = {}> {
+  options: T;
   alepha: Alepha;
   service: InstantiableClass<Service>;
   module?: Service;
@@ -82,22 +84,22 @@ interface DescriptorConfig {
   service: InstantiableClass<Service>;
   module?: Service;
 }
-declare abstract class Descriptor<T$1 extends object = {}> {
+declare abstract class Descriptor<T extends object = {}> {
   protected readonly alepha: Alepha;
-  readonly options: T$1;
+  readonly options: T;
   readonly config: DescriptorConfig;
-  constructor(args: DescriptorArgs<T$1>);
+  constructor(args: DescriptorArgs<T>);
   /**
    * Called automatically by Alepha after the descriptor is created.
    */
   protected onInit(): void;
 }
-type DescriptorFactory<TDescriptor$1 extends Descriptor = Descriptor> = {
-  (options: TDescriptor$1["options"]): TDescriptor$1;
-  [KIND]: InstantiableClass<TDescriptor$1>;
+type DescriptorFactory<TDescriptor extends Descriptor = Descriptor> = {
+  (options: TDescriptor["options"]): TDescriptor;
+  [KIND]: InstantiableClass<TDescriptor>;
 };
-type DescriptorFactoryLike<T$1 extends object = any> = {
-  (options: T$1): any;
+type DescriptorFactoryLike<T extends object = any> = {
+  (options: T): any;
   [KIND]: any;
 };
 declare const createDescriptor: <TDescriptor extends Descriptor>(descriptor: InstantiableClass<TDescriptor> & {
@@ -117,7 +119,7 @@ declare const createDescriptor: <TDescriptor extends Descriptor>(descriptor: Ins
  */
 declare const $inject: <T extends object>(type: Service<T>, opts?: InjectOptions<T>) => T;
 declare class InjectDescriptor extends Descriptor {}
-interface InjectOptions<T$1 extends object = any> {
+interface InjectOptions<T extends object = any> {
   /**
    * - 'transient' → Always a new instance on every inject. Zero caching.
    * - 'singleton' → One instance per Alepha runtime (per-thread). Never disposed until Alepha shuts down. (default)
@@ -132,7 +134,7 @@ interface InjectOptions<T$1 extends object = any> {
   /**
    * Constructor arguments to pass when creating a new instance.
    */
-  args?: ConstructorParameters<InstantiableClass<T$1>>;
+  args?: ConstructorParameters<InstantiableClass<T>>;
   /**
    * Parent that requested the instance.
    *
@@ -190,7 +192,7 @@ interface InjectOptions<T$1 extends object = any> {
  * If we speak with `$actions`, a module should be used when you have more than 30 actions in a single module.
  */
 declare const $module: <T extends object = {}>(options: ModuleDescriptorOptions<T>) => Service<Module<T>>;
-interface ModuleDescriptorOptions<T$1 extends object> {
+interface ModuleDescriptorOptions<T extends object> {
   /**
    * Name of the module.
    *
@@ -210,16 +212,16 @@ interface ModuleDescriptorOptions<T$1 extends object> {
    * 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, options: T$1) => void;
+  register?: (alepha: Alepha, options: T) => void;
 }
 /**
  * Base class for all modules.
  */
-declare abstract class Module<T$1 extends object = {}> {
-  abstract readonly config: ModuleDescriptorOptions<T$1>;
+declare abstract class Module<T extends object = {}> {
+  abstract readonly config: ModuleDescriptorOptions<T>;
   abstract register(alepha: Alepha): void;
   static NAME_REGEX: RegExp;
-  options: T$1;
+  options: T;
   /**
    * Check if a Service is a Module.
    */
@@ -229,7 +231,7 @@ declare abstract class Module<T$1 extends object = {}> {
    */
   static of(ctor: Service): Service<Module> | undefined;
 }
-type WithModule<T$1 extends object = any> = T$1 & {
+type WithModule<T extends object = any> = T & {
   [MODULE]?: Service;
 };
 //#endregion
@@ -237,7 +239,7 @@ type WithModule<T$1 extends object = any> = T$1 & {
 /**
  * Represents a value that can be either a value or a promise of value.
  */
-type Async<T$1> = T$1 | Promise<T$1>;
+type Async<T> = T | Promise<T>;
 /**
  * Represents a function that returns an async value.
  */
@@ -245,7 +247,7 @@ type AsyncFn = (...args: any[]) => Async<any>;
 /**
  * Transforms a type T into a promise if it is not already a promise.
  */
-type MaybePromise<T$1> = T$1 extends Promise<any> ? T$1 : Promise<T$1>;
+type MaybePromise<T> = T extends Promise<any> ? T : Promise<T>;
 //#endregion
 //#region src/interfaces/LoggerInterface.d.ts
 type LogLevel = "ERROR" | "WARN" | "INFO" | "DEBUG" | "TRACE" | "SILENT";
@@ -257,45 +259,6 @@ interface LoggerInterface {
   error(message: string, data?: unknown): void;
 }
 //#endregion
-//#region src/helpers/EventManager.d.ts
-declare class EventManager {
-  protected logFn?: () => LoggerInterface | undefined;
-  /**
-   * List of events that can be triggered. Powered by $hook().
-   */
-  protected events: Record<string, Array<Hook>>;
-  constructor(logFn?: () => LoggerInterface | undefined);
-  protected get log(): LoggerInterface | undefined;
-  /**
-   * Registers a hook for the specified event.
-   */
-  on<T extends keyof Hooks>(event: T, hookOrFunc: Hook<T> | ((payload: Hooks[T]) => Async<void>)): () => void;
-  /**
-   * Emits the specified event with the given payload.
-   */
-  emit<T extends keyof Hooks>(func: T, payload: Hooks[T], options?: {
-    /**
-     * If true, the hooks will be executed in reverse order.
-     * This is useful for "stop" hooks that should be executed in reverse order.
-     *
-     * @default false
-     */
-    reverse?: boolean;
-    /**
-     * If true, the hooks will be logged with their execution time.
-     *
-     * @default false
-     */
-    log?: boolean;
-    /**
-     * If true, errors will be caught and logged instead of throwing.
-     *
-     * @default false
-     */
-    catch?: boolean;
-  }): Promise<void>;
-}
-//#endregion
 //#region src/providers/AlsProvider.d.ts
 type AsyncLocalStorageData = any;
 declare class AlsProvider {
@@ -309,36 +272,15 @@ declare class AlsProvider {
   set<T>(key: string, value: T): void;
 }
 //#endregion
-//#region src/helpers/StateManager.d.ts
-declare class StateManager<S extends Record<string, any> = State> {
-  protected store: Partial<S>;
-  protected readonly events?: EventManager;
-  protected readonly als?: AlsProvider;
-  constructor(events?: EventManager, als?: AlsProvider);
-  /**
-   * Get a value from the state with proper typing
-   */
-  get<Key extends keyof S>(key: Key): S[Key] | undefined;
-  /**
-   * Set a value in the state
-   */
-  set<Key extends keyof S>(key: Key, value: S[Key] | undefined): this;
-  /**
-   * Check if a key exists in the state
-   */
-  has<Key extends keyof S>(key: Key): boolean;
-  /**
-   * Delete a key from the state (set to undefined)
-   */
-  del<Key extends keyof S>(key: Key): this;
-  /**
-   * Clear all state
-   */
-  clear(): this;
-  /**
-   * Get all keys that exist in the state
-   */
-  keys(): (keyof S)[];
+//#region src/providers/Json.d.ts
+/**
+ * Mimics the JSON global object with stringify and parse methods.
+ *
+ * Used across the codebase via dependency injection.
+ */
+declare class Json {
+  stringify(value: any, replacer?: (this: any, key: string, value: any) => any, space?: string | number): string;
+  parse(text: string, reviver?: (this: any, key: string, value: any) => any): any;
 }
 //#endregion
 //#region src/helpers/FileLike.d.ts
@@ -398,20 +340,20 @@ interface FileLike {
 /**
  * TypeBox view of FileLike.
  */
-type TFile = TUnsafe<FileLike>;
+type TFile = TUnsafe$1<FileLike>;
 declare const isTypeFile: (value: TSchema$1) => value is TFile;
 declare const isFileLike: (value: any) => value is FileLike;
 type StreamLike = ReadableStream | ReadableStream$1 | Readable | NodeJS.ReadableStream;
-type TStream = TUnsafe<StreamLike>;
+type TStream = TUnsafe$1<StreamLike>;
 //#endregion
 //#region src/providers/TypeProvider.d.ts
 declare const isUUID: typeof TypeBoxFormat.IsUuid;
-declare const isDateTime: typeof TypeBoxFormat.IsDateTime;
-declare const isDate: typeof TypeBoxFormat.IsDate;
 declare const isEmail: typeof TypeBoxFormat.IsEmail;
 declare const isURL: typeof TypeBoxFormat.IsUrl;
 declare class TypeGuard {
-  isSchema: typeof TypeBox.IsSchema;
+  isFile: (value: TSchema$1) => value is TFile;
+  isBigInt: (value: TSchema$1) => value is TString$1;
+  isUUID: (value: TSchema$1) => value is TString$1;
   isObject: typeof TypeBox.IsObject;
   isNumber: typeof TypeBox.IsNumber;
   isString: typeof TypeBox.IsString;
@@ -427,11 +369,8 @@ declare class TypeGuard {
   isRecord: typeof TypeBox.IsRecord;
   isTuple: typeof TypeBox.IsTuple;
   isVoid: typeof TypeBox.IsVoid;
-  isFile: (value: TSchema$1) => value is TFile;
-  isBigInt: (value: TSchema$1) => value is TString$1;
-  isDate: (value: TSchema$1) => value is TString$1;
-  isDatetime: (value: TSchema$1) => value is TString$1;
-  isUUID: (value: TSchema$1) => value is TString$1;
+  isLiteral: typeof TypeBox.IsLiteral;
+  isSchema: typeof TypeBox.IsSchema;
 }
 declare module "typebox" {
   interface TString {
@@ -445,6 +384,7 @@ declare module "typebox" {
 }
 declare class TypeProvider {
   static format: typeof TypeBoxFormat;
+  static setLocale(locale: string): void;
   static isValidBigInt(value: string | number): boolean;
   /**
    * Default maximum length for strings.
@@ -494,12 +434,13 @@ declare class TypeProvider {
   void: typeof TypeBox.Void;
   undefined: typeof TypeBox.Undefined;
   record: typeof TypeBox.Record;
-  omit: typeof TypeBox.Omit;
   partial: typeof TypeBox.Partial;
   union: typeof TypeBox.Union;
-  pick: typeof TypeBox.Pick;
   tuple: typeof TypeBox.Tuple;
   interface: typeof TypeBox.Interface;
+  null: typeof TypeBox.Null;
+  const: typeof TypeBox.Literal;
+  codec: typeof TypeBox.Codec;
   /**
    * Type guards to check the type of schema.
    * This is not a runtime type check, but a compile-time type guard.
@@ -512,6 +453,8 @@ declare class TypeProvider {
    * ```
    */
   readonly schema: TypeGuard;
+  pick<T extends TObject$1, Indexer extends PropertyKey[]>(schema: T, keys: [...Indexer], options?: TObjectOptions$1): TPick$1<T, TKeysToIndexer$1<Indexer>>;
+  omit<T extends TObject$1, Indexer extends PropertyKey[]>(schema: T, keys: [...Indexer], options?: TObjectOptions$1): TOmit<T, TKeysToIndexer$1<Indexer>>;
   /**
    * Create a schema for an object.
    * By default, additional properties are not allowed.
@@ -536,7 +479,7 @@ declare class TypeProvider {
    * Create a schema for a string.
    * For db or input fields, consider using `t.text()` instead, which has length limits.
    *
-   * If you need a string with specific format (e.g. email, uuid, date), consider using the corresponding method (e.g. `t.email()`, `t.uuid()`, `t.date()`).
+   * If you need a string with specific format (e.g. email, uuid), consider using the corresponding method (e.g. `t.email()`, `t.uuid()`).
    */
   string(options?: TStringOptions$1): TString$1;
   /**
@@ -563,6 +506,10 @@ declare class TypeProvider {
    * Create a schema for a signed 32-bit integer.
    */
   int(options?: TNumberOptions$1): TInteger$1;
+  /**
+   * @alias `t.int()`
+   */
+  integer(options?: TNumberOptions$1): TInteger$1;
   /**
    * Mimic a signed 64-bit integer.
    *
@@ -592,26 +539,20 @@ declare class TypeProvider {
   /**
    * Create a schema for a string enum.
    */
-  enum<T extends string[]>(values: [...T], options?: TStringOptions$1): TUnsafe<T[number]>;
+  enum<T extends string[]>(values: [...T], options?: TStringOptions$1): TUnsafe$1<T[number]>;
   /**
    * Create a schema for a bigint.
    * This is NOT a BigInt object, but a string that represents a bigint.
    */
-  bigint(options?: TStringOptions$1): TString$1;
-  /**
-   * Create a schema for a datetime.
-   * This is NOT a Date object, but a string in ISO 8601 format.
-   */
-  datetime(options?: TStringOptions$1): TString$1;
+  bigint(options?: TStringOptions$1): TypeBox.TCodec<TString$1, bigint>;
   /**
-   * Create a schema for a date.
-   * This is NOT a Date object, but a string in ISO 8601 date format (YYYY-MM-DD).
+   * Create a schema for a url.
    */
-  date(options?: TStringOptions$1): TString$1;
+  url(options?: TStringOptions$1): TypeBox.TCodec<TString$1, URL>;
   /**
-   * Create a schema for a url.
+   * Create a schema for binary data represented as a string.
    */
-  url(options?: TStringOptions$1): TString$1;
+  binary(options: TStringOptions$1): TypeBox.TCodec<TString$1, Uint8Array<ArrayBuffer>>;
   /**
    * Create a schema for uuid.
    */
@@ -685,6 +626,192 @@ interface TTextOptions extends TStringOptions$1 {
 }
 declare const t: TypeProvider;
 //#endregion
+//#region src/providers/SchemaCodec.d.ts
+declare abstract class SchemaCodec {
+  protected cache: Map<TSchema$1, Validator>;
+  protected guard: TypeGuard;
+  /**
+   * Encode the value to a string format.
+   */
+  abstract encodeToString(schema: TSchema$1, value: any): string;
+  /**
+   * Encode the value to a binary format.
+   */
+  abstract encodeToBinary(schema: TSchema$1, value: any): Uint8Array;
+  /**
+   * Transform a specific type for this codec.
+   * Return undefined to use the default schema, or return a new schema to replace it.
+   *
+   * Override this method to customize how specific types are handled in this codec.
+   * For example, a ProtobufCodec might keep BigInt as-is instead of converting to string.
+   */
+  protected abstract transformType(schema: TSchema$1): TSchema$1 | false | void;
+  encode<T extends TSchema$1>(schema: T, value: any): StaticEncode$1<T>;
+  decode<T extends TSchema$1>(schema: T, value: any): StaticDecode$1<T>;
+  protected validator<T extends TSchema$1>(schema: T): Validator<{}, T>;
+  /**
+   * Transform the schema for this codec.
+   * Override this method to provide custom schema transformations.
+   * This method should recursively transform all nested schemas.
+   */
+  protected transformSchema<T extends TSchema$1>(schema: T): TSchema$1;
+  /**
+   * Preprocess the value based on the schema before encoding.
+   *
+   * - Remove `undefined` values from objects. { a: 1, b: undefined } => { a: 1 }
+   */
+  beforeEncode: (schema: any, value: any) => any;
+  /**
+   * Preprocess the value based on the schema before validation.
+   *
+   * - If the value is `null` and the schema does not allow `null`, it converts it to `undefined`.
+   * - If the value is a string and the schema has a `~options.trim` flag, it trims whitespace from the string.
+   */
+  beforeDecode: (schema: any, value: any) => any;
+  /**
+   * Used by `preprocess` to determine if a schema allows null values.
+   */
+  protected isSchemaNullable: (schema: any) => boolean;
+}
+//#endregion
+//#region src/providers/JsonSchemaCodec.d.ts
+declare class JsonSchemaCodec extends SchemaCodec {
+  protected readonly json: Json;
+  protected readonly encoder: TextEncoder;
+  protected readonly decoder: TextDecoder;
+  protected transformType(schema: TSchema$1): TSchema$1 | false | void;
+  encodeToString(schema: TSchema$1, value: any): string;
+  encodeToBinary(schema: TSchema$1, value: any): Uint8Array;
+  decode<T extends TSchema$1>(schema: T, value: any): StaticDecode$1<T>;
+}
+//#endregion
+//#region src/providers/CodecManager.d.ts
+type Encoding = "object" | "string" | "binary";
+interface EncodeOptions<T extends Encoding = Encoding> {
+  /**
+   * The output encoding format:
+   * - 'object': Returns native types (objects, BigInt, Date, etc.)
+   * - 'string': Returns JSON string
+   * - 'binary': Returns Uint8Array (for protobuf, msgpack, etc.)
+   */
+  as?: T;
+  /**
+   * The encoder to use (e.g., 'json', 'protobuf', 'msgpack')
+   * Defaults to 'json'
+   */
+  encoder?: string;
+}
+type EncodeResult<T extends TSchema$1, E extends Encoding> = E extends "string" ? string : E extends "binary" ? Uint8Array : StaticEncode$1<T>;
+interface DecodeOptions {
+  /**
+   * The encoder to use (e.g., 'json', 'protobuf', 'msgpack')
+   * Defaults to 'json'
+   */
+  encoder?: string;
+}
+/**
+ * CodecManager manages multiple codec formats and provides a unified interface
+ * for encoding and decoding data with different formats.
+ */
+declare class CodecManager {
+  protected readonly codecs: Map<string, SchemaCodec>;
+  protected readonly jsonCodec: JsonSchemaCodec;
+  default: string;
+  constructor();
+  /**
+   * Register a new codec format.
+   * @param name - The name of the codec (e.g., 'json', 'protobuf')
+   * @param codec - The codec implementation
+   */
+  register(name: string, codec: SchemaCodec): void;
+  /**
+   * Get a specific codec by name.
+   * @param name - The name of the codec
+   * @returns The codec instance
+   * @throws {AlephaError} If the codec is not found
+   */
+  get(name: string): SchemaCodec;
+  /**
+   * Encode data using the specified codec and output format.
+   */
+  encode<T extends TSchema$1, E extends Encoding = "object">(schema: T, value: any, options?: EncodeOptions<E>): EncodeResult<T, E>;
+  /**
+   * Decode data using the specified codec.
+   */
+  decode<T extends TSchema$1>(schema: T, value: any, options?: DecodeOptions): StaticDecode$1<T>;
+}
+//#endregion
+//#region src/providers/EventManager.d.ts
+declare class EventManager {
+  protected logFn?: () => LoggerInterface | undefined;
+  /**
+   * List of events that can be triggered. Powered by $hook().
+   */
+  protected events: Record<string, Array<Hook>>;
+  constructor(logFn?: () => LoggerInterface | undefined);
+  protected get log(): LoggerInterface | undefined;
+  /**
+   * Registers a hook for the specified event.
+   */
+  on<T extends keyof Hooks>(event: T, hookOrFunc: Hook<T> | ((payload: Hooks[T]) => Async<void>)): () => void;
+  /**
+   * Emits the specified event with the given payload.
+   */
+  emit<T extends keyof Hooks>(func: T, payload: Hooks[T], options?: {
+    /**
+     * If true, the hooks will be executed in reverse order.
+     * This is useful for "stop" hooks that should be executed in reverse order.
+     *
+     * @default false
+     */
+    reverse?: boolean;
+    /**
+     * If true, the hooks will be logged with their execution time.
+     *
+     * @default false
+     */
+    log?: boolean;
+    /**
+     * If true, errors will be caught and logged instead of throwing.
+     *
+     * @default false
+     */
+    catch?: boolean;
+  }): Promise<void>;
+}
+//#endregion
+//#region src/providers/StateManager.d.ts
+declare class StateManager<S extends Record<string, any> = State> {
+  protected readonly als: AlsProvider;
+  protected readonly events: EventManager;
+  protected store: Partial<S>;
+  constructor(store?: Partial<S>);
+  /**
+   * Get a value from the state with proper typing
+   */
+  get<Key extends keyof S>(key: Key): S[Key] | undefined;
+  /**
+   * Set a value in the state
+   */
+  set<Key extends keyof S>(key: Key, value: S[Key] | undefined): this;
+  /**
+   * Check if a key exists in the state
+   */
+  has<Key extends keyof S>(key: Key): boolean;
+  /**
+   * Delete a key from the state (set to undefined)
+   */
+  del<Key extends keyof S>(key: Key): this;
+  /**
+   * Clear all state
+   */
+  clear(): this;
+  /**
+   * Get all keys that exist in the state
+   */
+  keys(): (keyof S)[];
+}
+//#endregion
 //#region src/Alepha.d.ts
 /**
  * Core container of the Alepha framework.
@@ -819,10 +946,6 @@ declare class Alepha {
    * If you are not interested about these helpers, you can use the constructor directly.
    */
   static create(state?: Partial<State>): Alepha;
-  /**
-   *  List of all services + how they are provided.
-   */
-  protected registry: Map<Service, ServiceDefinition>;
   /**
    * Flag indicating whether the App won't accept any further changes.
    * Pass to true when #start() is called.
@@ -845,33 +968,11 @@ declare class Alepha {
    */
   protected starting?: PromiseWithResolvers<this>;
   /**
-   * The current state of the App.
-   *
-   * It contains the environment variables, logger, and other state-related properties.
-   *
-   * You can declare your own state properties by extending the `State` interface.
-   *
-   * ```ts
-   * declare module "alepha" {
-   *   interface State {
-   *     myCustomValue: string;
-   *   }
-   * }
-   * ```
-   *
-   * Same story for the `Env` interface.
-   * ```ts
-   * declare module "alepha" {
-   *   interface Env {
-   *     readonly myCustomValue: string;
-   *   }
-   * }
-   * ```
+   * Initial state of the container.
    *
-   * State values can be function or primitive values.
-   * However, all .env variables must serializable to JSON.
+   * > Used to initialize the StateManager.
    */
-  protected store: State;
+  protected init: State;
   /**
    * During the instantiation process, we keep a list of pending instantiations.
    * > It allows us to detect circular dependencies.
@@ -882,22 +983,34 @@ declare class Alepha {
    * > It allows us to avoid parsing the same schema multiple times.
    */
   protected cacheEnv: Map<TSchema, any>;
-  /**
-   * Cache for TypeBox type checks.
-   * > It allows us to avoid compiling the same schema multiple times.
-   */
-  protected cacheTypeCheck: Map<TSchema, Validator>;
   /**
    * List of modules that are registered in the container.
    *
    * Modules are used to group services and provide a way to register them in the container.
    */
   protected modules: Array<Module>;
+  /**
+   * List of service substitutions.
+   *
+   * Services registered here will be replaced by the specified service when injected.
+   */
   protected substitutions: Map<Service, {
     use: Service;
   }>;
+  /**
+   * Configuration states for services.
+   *
+   * Used to configure services when they are instantiated.
+   */
   protected configurations: Map<Service, object>;
+  /**
+   * Registry of descriptors.
+   */
   protected descriptorRegistry: Map<Service<Descriptor<{}>>, Descriptor<{}>[]>;
+  /**
+   *  List of all services + how they are provided.
+   */
+  protected registry: Map<Service, ServiceDefinition>;
   /**
    * Node.js feature that allows to store context across asynchronous calls.
    *
@@ -905,15 +1018,21 @@ declare class Alepha {
    *
    * Mocked for browser environments.
    */
-  readonly context: AlsProvider;
+  get context(): AlsProvider;
   /**
    * Event manager to handle lifecycle events and custom events.
    */
-  readonly events: EventManager;
+  get events(): EventManager;
   /**
    * State manager to store arbitrary values.
    */
-  readonly state: StateManager<State>;
+  get state(): StateManager<Record<string, any>>;
+  /**
+   * Codec manager for encoding and decoding data with different formats.
+   *
+   * Supports multiple codec formats (JSON, Protobuf, etc.) with a unified interface.
+   */
+  get codec(): CodecManager;
   /**
    * Get logger instance.
    */
@@ -922,7 +1041,7 @@ declare class Alepha {
    * The environment variables for the App.
    */
   get env(): Readonly<Env>;
-  constructor(state?: Partial<State>);
+  constructor(init?: Partial<State>);
   /**
    * True when start() is called.
    *
@@ -958,7 +1077,7 @@ declare class Alepha {
   /**
    * Returns whether the App is running in a serverless environment.
    */
-  isServerless(): boolean | "vercel";
+  isServerless(): boolean;
   /**
    * Returns whether the App is in test mode. (Running in a test environment)
    *
@@ -1082,43 +1201,6 @@ declare class Alepha {
   configure<T extends {
     options?: object;
   }>(service: Service<T>, state: Partial<T["options"]>): this;
-  /**
-   * Casts the given value to the specified schema.
-   *
-   * It uses the TypeBox library to validate the value against the schema.
-   */
-  parse<T extends TSchema>(schema: T, value?: unknown, opts?: {
-    /**
-     * Clone the value before parsing.
-     * @default true
-     */
-    clone?: boolean;
-    /**
-     * Apply default values defined in the schema.
-     * @default true
-     */
-    default?: boolean;
-    /**
-     * Remove all values not defined in the schema.
-     * @default true
-     */
-    clean?: boolean;
-    /**
-     * Try to cast/convert some data based on the schema.
-     * @default true
-     */
-    convert?: boolean;
-    /**
-     * Convert `null` to `undefined`
-     * @default true
-     */
-    convertNullToUndefined?: boolean;
-    /**
-     * Prepare value after being deserialized.
-     * @default true
-     */
-    check?: boolean;
-  }): Static$1<T>;
   /**
    * Applies environment variables to the provided schema and state object.
    *
@@ -1144,20 +1226,20 @@ declare class Alepha {
   protected new<T extends object>(service: Service<T>, args?: any[]): T;
   protected processDescriptor(value: Descriptor, propertyKey?: string): void;
 }
-interface Hook<T$1 extends keyof Hooks = any> {
+interface Hook<T extends keyof Hooks = any> {
   caller?: Service;
   priority?: "first" | "last";
-  callback: (payload: Hooks[T$1]) => Async<void>;
+  callback: (payload: Hooks[T]) => Async<void>;
 }
 /**
  * This is how we store services in the Alepha container.
  */
-interface ServiceDefinition<T$1 extends object = any> {
+interface ServiceDefinition<T extends object = any> {
   /**
    * The instance of the class or type definition.
    * Mostly used for caching / singleton but can be used for other purposes like forcing the instance.
    */
-  instance: T$1;
+  instance: T;
   /**
    * List of classes which use this class.
    */
@@ -1229,8 +1311,8 @@ interface Hooks {
     prevValue: any;
   };
 }
-interface Configurable<T$1 extends object = any> {
-  options: T$1;
+interface Configurable<T extends object = any> {
+  options: T;
 }
 //#endregion
 //#region src/interfaces/Run.d.ts
@@ -1387,15 +1469,15 @@ declare const $hook: {
   <T extends keyof Hooks>(options: HookOptions<T>): HookDescriptor<T>;
   [KIND]: typeof HookDescriptor;
 };
-interface HookOptions<T$1 extends keyof Hooks> {
+interface HookOptions<T extends keyof Hooks> {
   /**
    * The name of the hook. "configure", "start", "ready", "stop", ...
    */
-  on: T$1;
+  on: T;
   /**
    * The handler to run when the hook is triggered.
    */
-  handler: (args: Hooks[T$1]) => Async<any>;
+  handler: (args: Hooks[T]) => Async<any>;
   /**
    * Force the hook to run first or last on the list of hooks.
    */
@@ -1409,7 +1491,7 @@ interface HookOptions<T$1 extends keyof Hooks> {
    */
   after?: object | Array<object>;
 }
-declare class HookDescriptor<T$1 extends keyof Hooks> extends Descriptor<HookOptions<T$1>> {
+declare class HookDescriptor<T extends keyof Hooks> extends Descriptor<HookOptions<T>> {
   called: number;
   protected onInit(): void;
 }
@@ -1450,23 +1532,32 @@ declare class TooLateSubstitutionError extends AlephaError {
 declare class TypeBoxError extends AlephaError {
   readonly name = "TypeBoxError";
   readonly cause: TLocalizedValidationError;
-  readonly value: any;
-  constructor(error: TLocalizedValidationError, value: any);
+  readonly value: {
+    path: string;
+    message: string;
+  };
+  constructor(error: TLocalizedValidationError);
+}
+interface TypeBoxErrorParams {
+  requiredProperties?: string[];
 }
 //#endregion
 //#region src/index.d.ts
-declare global {
-  interface ImportMetaEnv {
-    SSR: boolean;
-  }
-  interface ImportMeta {
-    readonly env: ImportMetaEnv;
-  }
-}
 /**
+ * Run Alepha application, trigger start lifecycle.
  *
+ * ```ts
+ * import { Alepha, run } from "alepha";
+ * import { MyService } from "./services/MyService.ts";
+ *
+ * const alepha = new Alepha({ env: { APP_NAME: "MyAlephaApp" } });
+ *
+ * alepha.with(MyService);
+ *
+ * export default run(alepha);
+ * ```
  */
-declare const run: (entry: Alepha | Service | Array<Service>, opts?: RunOptions) => void;
+declare const run: (entry: Alepha | Service | Array<Service>, opts?: RunOptions) => Alepha;
 //#endregion
-export { $cursor, $env, $hook, $inject, $module, AbstractClass, Alepha, AlephaError, AlsProvider, AppNotStartedError, Async, AsyncFn, AsyncLocalStorageData, CircularDependencyError, Configurable, ContainerLockedError, CursorDescriptor, Descriptor, DescriptorArgs, DescriptorConfig, DescriptorFactory, DescriptorFactoryLike, Env, FileLike, Hook, HookDescriptor, HookOptions, Hooks, InjectDescriptor, InjectOptions, InstantiableClass, KIND, LogLevel, LoggerInterface, MaybePromise, Module, ModuleDescriptorOptions, OPTIONS, Service, ServiceEntry, ServiceSubstitution, State, StateManager, type Static, type StaticDecode, type StaticEncode, StreamLike, type TAny, type TArray, type TBigInt, type TBoolean, TFile, type TInteger, type TKeysToIndexer, type TNull, type TNumber, type TNumberOptions, type TObject, type TObjectOptions, type TOptional, type TOptionalAdd, type TPick, type TProperties, type TRecord, type TSchema, TStream, type TString, type TStringOptions, TTextOptions, type TTuple, type TUnion, type TVoid, TextLength, TooLateSubstitutionError, TypeBox, TypeBoxError, TypeBoxFormat, TypeBoxValue, TypeGuard, TypeProvider, WithModule, __alephaRef, createDescriptor, isDate, isDateTime, isEmail, isFileLike, isTypeFile, isURL, isUUID, run, t };
+export { $cursor, $env, $hook, $inject, $module, AbstractClass, Alepha, AlephaError, AlsProvider, AppNotStartedError, Async, AsyncFn, AsyncLocalStorageData, CircularDependencyError, CodecManager, Configurable, ContainerLockedError, CursorDescriptor, DecodeOptions, Descriptor, DescriptorArgs, DescriptorConfig, DescriptorFactory, DescriptorFactoryLike, EncodeOptions, EncodeResult, Encoding, Env, FileLike, Hook, HookDescriptor, HookOptions, Hooks, InjectDescriptor, InjectOptions, InstantiableClass, JsonSchemaCodec, KIND, LogLevel, LoggerInterface, MaybePromise, Module, ModuleDescriptorOptions, OPTIONS, RunFunction, SchemaCodec, Service, ServiceEntry, ServiceSubstitution, State, StateManager, type Static, type StaticDecode, type StaticEncode, StreamLike, type TAny, type TArray, type TBigInt, type TBoolean, TFile, type TInteger, type TKeysToIndexer, type TNull, type TNumber, type TNumberOptions, type TObject, type TObjectOptions, type TOptional, type TOptionalAdd, type TPick, type TProperties, type TRecord, type TSchema, TStream, type TString, type TStringOptions, TTextOptions, type TTuple, type TUnion, type TUnsafe, type TVoid, TextLength, TooLateSubstitutionError, TypeBox, TypeBoxError, TypeBoxErrorParams, TypeBoxFormat, TypeBoxValue, TypeGuard, TypeProvider, WithModule, __alephaRef, createDescriptor, isClass, isEmail, isFileLike, isTypeFile, isURL, isUUID, run, t };
 //# sourceMappingURL=index.d.ts.map