alepha 0.10.6 → 0.11.0

package/core.d.ts

@@ -1,7 +1,7 @@
 import { AsyncLocalStorage } from "node:async_hooks";
-import { Validator } from "typebox/compile";
 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 { Validator } from "typebox/compile";
 import TypeBoxFormat from "typebox/format";
 import * as TypeBoxValue from "typebox/value";
 import { Readable } from "node:stream";
@@ -28,7 +28,8 @@ 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 extends object = any> = InstantiableClass<T> | AbstractClass<T>;
+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!
@@ -69,6 +70,7 @@ 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>;
+declare function isClass(func: any): func is InstantiableClass;
 //#endregion
 //#region src/helpers/descriptor.d.ts
 interface DescriptorArgs<T extends object = {}> {
@@ -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: keyof Hooks, 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.
    */
@@ -630,10 +571,26 @@ declare class TypeProvider {
    * @experimental
    */
   stream(): TStream;
+  email(options?: TStringOptions$1): TString$1;
+  e164(options?: TStringOptions$1): TString$1;
+  bcp47(options?: TStringOptions$1): TString$1;
+  /**
+   * Create a schema for short text, such as names or titles.
+   * Default max length is 64 characters.
+   */
+  shortText(options?: TStringOptions$1): TString$1;
+  /**
+   * Create a schema for long text, such as descriptions or comments.
+   * Default max length is 1024 characters.
+   */
+  longText(options?: TStringOptions$1): TString$1;
+  /**
+   * Create a schema for rich text, such as HTML or Markdown.
+   * Default max length is 65535 characters.
+   */
+  richText(options?: TStringOptions$1): TString$1;
   /**
    * Create a schema for a string enum e.g. LIKE_THIS.
-   *
-   * @param options
    */
   snakeCase: (options?: TStringOptions$1) => TString$1;
   /**
@@ -669,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.
@@ -803,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.
@@ -829,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.
+   * Initial state of the container.
    *
-   * ```ts
-   * declare module "alepha" {
-   *   interface State {
-   *     myCustomValue: string;
-   *   }
-   * }
-   * ```
-   *
-   * Same story for the `Env` interface.
-   * ```ts
-   * declare module "alepha" {
-   *   interface Env {
-   *     readonly myCustomValue: string;
-   *   }
-   * }
-   * ```
-   *
-   * 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.
@@ -866,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.
    *
@@ -889,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.
    */
@@ -906,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.
    *
@@ -935,12 +1070,14 @@ declare class Alepha {
    * True if the App is running in a browser environment.
    */
   isBrowser(): boolean;
+  /**
+   * Returns whether the App is running in Vite dev mode.
+   */
+  isViteDev(): boolean;
   /**
    * Returns whether the App is running in a serverless environment.
-   *
-   * > Vite developer mode is also considered serverless.
    */
-  isServerless(): boolean | "vite" | "vercel";
+  isServerless(): boolean;
   /**
    * Returns whether the App is in test mode. (Running in a test environment)
    *
@@ -1064,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.
    *
@@ -1211,6 +1311,9 @@ interface Hooks {
     prevValue: any;
   };
 }
+interface Configurable<T extends object = any> {
+  options: T;
+}
 //#endregion
 //#region src/interfaces/Run.d.ts
 interface RunOptions {
@@ -1429,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, 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