alepha 0.6.7 → 0.6.9

package/core.d.ts

@@ -1,19 +1,998 @@
-export * from '@alepha/core';
-import '@alepha/vite';
-import '@alepha/datetime';
-import '@alepha/react';
-import '@alepha/react-auth';
-import '@alepha/cache';
-import '@alepha/postgres';
-import '@alepha/redis';
-import '@alepha/lock';
-import '@alepha/topic';
-import '@alepha/queue';
-import '@alepha/scheduler';
-import '@alepha/security';
-import '@alepha/server';
-import '@alepha/server-cookies';
-import '@alepha/server-metrics';
-import '@alepha/server-proxy';
-import '@alepha/server-static';
-import '@alepha/server-swagger';
+import * as TypeBox from '@sinclair/typebox';
+import { TSchema, Static, TObject, FormatRegistry, SchemaOptions, ObjectOptions, Union, TProperties, ArrayOptions, TArray, StringOptions, TString, TBoolean, NumberOptions, TNumber, IntegerOptions, TInteger, TOptionalWithFlag, TNull, TIntersect, TUnsafe, UnsafeOptions } from '@sinclair/typebox';
+export { TypeBox };
+export { Static, StaticDecode, StaticEncode, TObject, TSchema, TypeGuard } from '@sinclair/typebox';
+import { TypeCheck } from '@sinclair/typebox/compiler';
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { ValueError } from '@sinclair/typebox/errors';
+import { ReadableStream as ReadableStream$1 } from 'node:stream/web';
+import * as TypeBoxValue from '@sinclair/typebox/value';
+export { TypeBoxValue };
+import { Readable } from 'node:stream';
+
+/**
+ * Used for identifying descriptors.
+ *
+ * @internal
+ */
+declare const KIND: unique symbol;
+
+/**
+ * Represents a value that can be either a value or a promise.
+ */
+type Async<T> = T | Promise<T>;
+/**
+ * Represents a function that returns a promise.
+ */
+type PromiseFn = (...args: any[]) => Promise<any>;
+/**
+ * Represents a function that returns an async value.
+ */
+type AsyncFn = (...args: any[]) => Async<any>;
+
+/**
+ * Represents a generic definition type in TypeScript.
+ */
+interface Class<T extends object = any> {
+    new (...args: any[]): T;
+}
+/**
+ *
+ */
+interface ClassSwap<T extends object = any> {
+    /**
+     * Class to register.
+     */
+    provide: Class<T>;
+    /**
+     * Class to use AS the provided class.
+     */
+    use: Class<T>;
+    /**
+     * If true, "use" only if class is not already registered.
+     */
+    default?: boolean;
+    /**
+     * If true, class will be removed if nobody is using it.
+     */
+    optional?: boolean;
+}
+/**
+ *
+ */
+type ClassEntry<T extends object = any> = Class<T> | ClassSwap<T>;
+/**
+ * Represents a definition for a class.
+ */
+interface ClassProvider<T extends object = any> {
+    /**
+     * The class or type definition to provide.
+     */
+    provide: Class<T>;
+    /**
+     * The class or type definition to use. This will override the 'provide' property.
+     */
+    use?: Class<T>;
+    /**
+     * 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;
+    /**
+     * List of classes which use this class.
+     */
+    parents: Array<Class | null>;
+}
+
+/**
+ * Used for identifying descriptors.
+ *
+ * @internal
+ */
+declare const OPTIONS: unique symbol;
+
+declare const KEY = "HOOK";
+interface Hooks {
+    /**
+     * Triggered during the configuration phase. Before the start phase.
+     *
+     * - Configuration should technically be called many times without any side effects.
+     * - Spamming Alepha#configure() should not cause any issues.
+     */
+    configure: Alepha;
+    /**
+     * Triggered during the start phase. When `Alepha#start()` is called.
+     *
+     * - Start is called only once. It should not be called multiple times.
+     */
+    start: Alepha;
+    /**
+     * Triggered during the ready phase. After the start phase.
+     *
+     * - Ready is called only once. It should not be called multiple times.
+     */
+    ready: Alepha;
+    /**
+     * Triggered during the stop phase.
+     *
+     * - Stop is called only once. It should not be called multiple times.
+     * - Stop should be called after a SIGINT or SIGTERM signal in order to gracefully shutdown the application.
+     */
+    stop: Alepha;
+}
+interface HookOptions<T extends keyof Hooks> {
+    /**
+     * The name of the hook. "configure", "start", "ready", "stop", ...
+     */
+    name: T;
+    /**
+     * The handler to run when the hook is triggered.
+     */
+    handler: (app: Hooks[T]) => Async<any>;
+    before?: object | Array<object>;
+    after?: object | Array<object>;
+    priority?: "first" | "last";
+}
+interface Hook<T extends keyof Hooks = any> {
+    caller?: Class;
+    priority?: "first" | "last";
+    callback: (payload: Hooks[T]) => Async<void>;
+}
+interface HookDescriptor<T extends keyof Hooks> {
+    [KIND]: typeof KEY;
+    [OPTIONS]: HookOptions<T>;
+    (app: Hooks[T]): Async<any>;
+}
+/**
+ * Registers a new hook.
+ *
+ * ```ts
+ * import { $hook } from "alepha";
+ *
+ * class MyProvider {
+ *   onStart = $hook({
+ *     name: "start", // or "configure", "ready", "stop", ...
+ *     handler: async (app) => {
+ *       // await db.connect(); ...
+ *     }
+ *   });
+ * }
+ * ```
+ *
+ * Hooks are used to run async functions from all registered providers/services.
+ *
+ * - You can't unregister a hook once it has been registered.
+ * - You can't register a hook after the App has started.
+ *
+ * It's used under the hood by the `configure`, `start`, and `stop` methods.
+ * Some modules also use hooks to run their own logic.
+ */
+declare const $hook: {
+    <T extends keyof Hooks>(options: HookOptions<T>): HookDescriptor<T>;
+    [KIND]: string;
+};
+
+/**
+ * Used to store the current context and definition during injections.
+ *
+ * @internal
+ */
+declare const __alephaRef: {
+    context?: Alepha;
+    definition?: Class;
+};
+/**
+ * Cursor descriptor.
+ */
+interface CursorDescriptor {
+    context: Alepha;
+    definition?: Class;
+}
+/**
+ * Get Alepha instance and Class definition from the current context.
+ *
+ * This should be used inside a descriptor only.
+ *
+ * @internal
+ */
+declare const $cursor: () => CursorDescriptor;
+
+/**
+ * Light-weight event emitter like.
+ */
+declare class EventEmitterLike<TEvents extends {
+    [key: string]: any;
+}> {
+    private hooks;
+    on<T extends keyof TEvents>(event: T, callback: (data: TEvents[T]) => void): void;
+    emit<T extends keyof TEvents>(event: T, data: TEvents[T]): void;
+}
+/**
+ * Descriptor events.
+ *
+ * - `create` - Emitted when a descriptor is created.
+ */
+declare const descriptorEvents: EventEmitterLike<{
+    create: CursorDescriptor & {
+        [KIND]: string;
+    };
+}>;
+/**
+ * Register a descriptor.
+ *
+ * This is used to run the event "create" and allow auto-registration of descriptors.
+ *
+ * @internal
+ * @param kind
+ */
+declare const __descriptor: (kind: string) => void;
+/**
+ * Auto-inject a class/module when a descriptor is created.
+ *
+ * Like, you auto-inject the ServerModule when a `$route` descriptor is used.
+ *
+ * @param descriptor
+ * @param to
+ */
+declare const __bind: (descriptor: {
+    [KIND]: string;
+}, ...to: Class[]) => void;
+/**
+ * Check if the value is a descriptor value.
+ *
+ * @param value - Value to check.
+ * @returns Is the value a descriptor value.
+ */
+declare const isDescriptorValue: (value: any) => value is DescriptorIdentifier;
+/**
+ * The "$descriptor" function.
+ */
+interface Descriptor<T extends object = any> {
+    [KIND]: string;
+    (options: T): DescriptorIdentifier<T>;
+}
+/**
+ * Class member descriptor.
+ */
+interface DescriptorIdentifier<T = object> {
+    [KIND]: string;
+    [OPTIONS]: T;
+}
+/**
+ * Descriptor identifier + his instance + his key.
+ */
+interface DescriptorItem<T extends Descriptor> {
+    value: ReturnType<T>;
+    key: string;
+    instance: Record<string, any>;
+}
+
+type AsyncLocalStorageData = any;
+declare class AsyncLocalStorageProvider {
+    protected als?: AsyncLocalStorage<AsyncLocalStorageData>;
+    configure(): Promise<void>;
+    run<R>(data: AsyncLocalStorageData, callback: () => R): R;
+    get<T>(key: string): T | undefined;
+    set<T>(key: string, value: T): void;
+}
+
+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"
+     */
+    LOG_LEVEL?: "trace" | "debug" | "info" | "warn" | "error" | "silent";
+    /**
+     * 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";
+}
+interface LoggerOptions {
+    /**
+     * The logging level. Can be one of "error", "warn", "info", "debug", or "trace".
+     */
+    level?: LogLevel;
+    /**
+     * 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;
+    /**
+     * Whether to log in JSON format. Defaults to false.
+     */
+    json?: boolean;
+    /**
+     * An optional async local storage provider to use for storing context information.
+     */
+    als?: AsyncLocalStorageProvider;
+}
+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<LogLevel, string>;
+declare class Logger {
+    protected levelOrder: Record<LogLevel, number>;
+    readonly level: LogLevel;
+    readonly name: string;
+    protected caller: string;
+    protected context: string;
+    protected color: boolean;
+    protected json: boolean;
+    protected als?: AsyncLocalStorageProvider;
+    constructor(options?: LoggerOptions);
+    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.
+     *
+     * @param level
+     * @param message
+     * @param data
+     * @protected
+     */
+    protected log(level: LogLevel, message: unknown, data?: object | Error | string): void;
+    /**
+     * Print a log message to the console.
+     *
+     * @param formatted
+     * @protected
+     */
+    protected print(formatted: string): void;
+    /**
+     * Format a log message to JSON.
+     *
+     * @param level
+     * @param message
+     * @param data
+     * @protected
+     */
+    protected formatJson(level: LogLevel, message: unknown, data?: object | Error | string): string;
+    /**
+     * Format a log message to a string.
+     *
+     * @param level
+     * @param message
+     * @param data
+     * @protected
+     */
+    protected formatLog(level: LogLevel, message: string, data?: object | Error): 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;
+}
+interface MockLoggerStore {
+    stack: Array<{
+        date: string;
+        level: string;
+        msg: string;
+        data?: object;
+    }>;
+}
+
+interface Env extends LoggerEnv {
+    [key: string]: string | boolean | number | undefined;
+    /**
+     *
+     */
+    NODE_ENV?: "dev" | "test" | "production";
+    /**
+     * Optional name of the application.
+     */
+    APP_NAME?: string;
+    /**
+     * If true, the container will not automatically register the default providers.
+     * Default is false.
+     */
+    EXPLICIT_PROVIDERS?: boolean;
+}
+interface State {
+    log: Logger;
+    env?: Readonly<Env>;
+    beforeAll?: (run: any) => any;
+    afterAll?: (run: any) => any;
+    afterEach?: (run: any) => any;
+    onTestFinished?: (run: any) => any;
+}
+/**
+ *
+ *
+ * @example
+ * ```ts
+ * const app = Alepha.create();
+ * ```
+ */
+declare class Alepha {
+    /**
+     * Syntactic sugar for creating a new instance of the container.
+     * Equivalent to `Alepha.create()`.
+     */
+    static create(state?: Partial<State>): Alepha;
+    /**
+     *  List of all services + how they are provided.
+     */
+    protected registry: Map<Class, ClassProvider>;
+    /**
+     * Flag indicating whether the App won't accept any further changes.
+     * Pass to true when #start() is called.
+     */
+    protected locked: boolean;
+    /**
+     * True if the App has been configured.
+     */
+    protected configured: boolean;
+    /**
+     * True if the App has started.
+     */
+    protected started: boolean;
+    /**
+     * True if the App is ready.
+     */
+    protected ready: boolean;
+    /**
+     * The state of the App.
+     */
+    protected _starting?: PromiseWithResolvers<this>;
+    protected _state: State;
+    protected _dependencyStack: Class[];
+    protected _lazyRegistrations: Array<Promise<{
+        default: Class<object>;
+    }>>;
+    protected _cacheEnv: Map<TSchema, any>;
+    protected _cacheTypeCheck: Map<TSchema, TypeCheck<TSchema>>;
+    protected _events: Record<string, Array<Hook>>;
+    readonly als: AsyncLocalStorageProvider;
+    get log(): Logger;
+    handle?: (req: any, res: any) => Promise<any>;
+    /**
+     * The environment variables for the App.
+     */
+    get env(): Readonly<Env>;
+    constructor(state?: Partial<State>);
+    /**
+     * State accessor.
+     */
+    state<Key extends keyof State>(key: Key, value?: State[Key]): State[Key];
+    /**
+     *
+     */
+    graph(): Record<string, {
+        from: string[];
+        as?: string;
+    }>;
+    /**
+     * True if the App is running in a browser environment.
+     */
+    isBrowser(): boolean;
+    /**
+     * Returns whether the App has started.
+     *
+     * It means that #start() has been called but maybe not all services are ready.
+     */
+    isStarted(): boolean;
+    /**
+     * True if the App is ready. It means that Alepha is started AND ready() hook has beed called.
+     */
+    isReady(): boolean;
+    /**
+     * True when start() is called. No more services can be added.
+     */
+    isLocked(): boolean;
+    isConfigured(): boolean;
+    /**
+     * Returns whether the App is running in a serverless environment.
+     */
+    isServerless(): boolean | "vite" | "vercel";
+    /**
+     * Returns whether the App is in test mode. (Running in a test environment)
+     */
+    isTest(): boolean;
+    /**
+     * Returns whether the App is in production mode. (Running in a production environment)
+     */
+    isProduction(): boolean;
+    /**
+     * > configure() is automatically called by start().
+     * Use this method only if you need to configure the App without starting it.
+     *
+     * @internal
+     */
+    configure(): Promise<this | undefined>;
+    /**
+     * Starts the App.
+     *
+     * - Lock any further changes to the container.
+     * - Run "configure" hook for all services.
+     * - Run "start" hook for all services.
+     *
+     * @return A promise that resolves when the App has started.
+     */
+    start(): Promise<this>;
+    /**
+     * Stops the App.
+     *
+     * - Run "stop" hook for all services.
+     *
+     * @return A promise that resolves when the App has stopped.
+     */
+    stop(): Promise<void>;
+    /**
+     * Returns whether the specified class or type is registered in the container.
+     *
+     * @param injectable - The class or type definition to check.
+     * @param opts - Additional options for the check.
+     * @return True if the class or type is registered in the container, false otherwise.
+     */
+    has(injectable: ClassEntry, opts?: {
+        overridden?: boolean;
+        pending?: boolean;
+    }): boolean;
+    /**
+     * Registers the specified class or type in the container.
+     *
+     * - If the class or type is already registered, the method does nothing.
+     * - If the class or type is not registered, a new instance is created and registered.
+     *
+     * ClassEntry allows to provide a class swapping feature.
+     *
+     * @example
+     * ```ts
+     * class A { value = "a"; }
+     * class B { value = "b"; }
+     * class M { a = $inject(A); }
+     *
+     * Alepha.create().register({ provide: A, use: B }).get(M).a.value; // "b"
+     * ```
+     *
+     * > Swapping is an advanced feature that allows you to replace a class with another class.
+     * > It's useful for testing or for providing different implementations of a class.
+     *
+     * @param it - The class or type definitions to register in the container.
+     * @return The current instance of the container.
+     */
+    register<T extends object>(it: ClassEntry<T> | Promise<{
+        default: Class<object>;
+    }>): this;
+    /**
+     * Alias for the 'register' method.
+     *
+     * @alias {Alepha#register}
+     */
+    with: <T extends object>(it: ClassEntry<T> | Promise<{
+        default: Class<object>;
+    }>) => this;
+    /**
+     * Works like 'Alepha#register' but it must return the instance.
+     *
+     * @param entry - The class or type definition to retrieve or create.
+     * @param opts
+     * @param opts.parent - The parent class that requested the instance.
+     * @return The instance of the specified class or type.
+     */
+    get<T extends object>(entry: ClassEntry<T>, opts?: {
+        parent?: Class | null;
+        skipCache?: boolean;
+        skipRegistration?: boolean;
+        args?: any[];
+    }): T;
+    on<T extends keyof Hooks>(event: T, hook: Hook<T>): () => void;
+    emit<T extends keyof Hooks>(func: keyof Hooks, payload: Hooks[T], options?: {
+        reverse?: boolean;
+        log?: boolean;
+    }): Promise<void>;
+    /**
+     * Casts the given value to the specified schema.
+     *
+     * It uses the TypeBox library to validate the value against the schema.
+     *
+     * @param schema - The schema to cast the value to.
+     * @param value - The value to cast.
+     * @param opts - default: true, clean: true, convert: true, decode: true, encode: false
+     */
+    parse<T extends TSchema>(schema: T, value?: any, 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;
+        /**
+         * Prepare value after being deserialized.
+         * @default true
+         */
+        check?: boolean;
+    }): Static<T>;
+    /**
+     * Applies environment variables to the provided schema and state object.
+     *
+     * It replaces also all templated $ENV inside string values.
+     *
+     * @param schema - The schema object to apply environment variables to.
+     * @return The schema object with environment variables applied.
+     */
+    parseEnv<T extends TObject>(schema: T): Static<T>;
+    /**
+     * Returns all registered services that match the specified descriptor.
+     *
+     * @param descriptor
+     */
+    getDescriptorValues<T extends Descriptor>(descriptor: T): Array<DescriptorItem<T>>;
+    /**
+     * Create a new instance of a logger.
+     *
+     * @returns The newly created logger instance.
+     */
+    protected createLogger(env: Env): Logger;
+    /**
+     * Creates a new instance of a given class with dependency injection.
+     *
+     * @param definition - The class for which to create a new instance.
+     * @param args - The arguments to pass to the class constructor
+     * @returns The newly created instance of the given class.
+     */
+    protected new<T extends object>(definition: Class<T>, args?: any[]): T;
+    /**
+     * Removes all useless dependencies.
+     *
+     * @protected
+     */
+    protected removeUselessDependencies(): void;
+}
+
+/**
+ * Symbol to mark a value create from a provider.
+ *
+ * @internal
+ */
+declare const PROVIDER: unique symbol;
+
+/**
+ * Get the instance of the specified type from the context.
+ *
+ * - If the type is a class, it will be resolved from the context.
+ * - If the type is a schema, it will be parsed from the environment.
+ *
+ * ```ts
+ * class A { }
+ * class B {
+ *   a = $inject(A);
+ * }
+ * ```
+ *
+ * @param type - Type (or TypeBox schema) to resolve
+ * @returns Instance of the specified type
+ */
+declare function $inject<T extends TObject>(type: T): Static<T>;
+declare function $inject<T extends object>(type: Class<T>): T;
+
+declare const $logger: (name?: string) => Logger;
+
+/**
+ * Retry Descriptor options.
+ */
+interface RetryDescriptorOptions<T extends (...args: any[]) => any> {
+    /**
+     *
+     */
+    max?: number;
+    /**
+     *
+     */
+    delay?: number;
+    /**
+     *
+     */
+    when?: (error: Error) => boolean;
+    /**
+     *
+     */
+    handler: T;
+}
+/**
+ * Retry descriptor.
+ *
+ * @param opts - Retry descriptor options.
+ * @returns A function that will retry the handler.
+ */
+declare const $retry: <T extends (...args: any[]) => any>(opts: RetryDescriptorOptions<T>) => ((...parameters: Parameters<T>) => Promise<ReturnType<T>>);
+
+declare class AppNotStartedError extends Error {
+    constructor();
+}
+
+declare class CircularDependencyError extends Error {
+    constructor(provider: string, parents?: string[]);
+}
+
+declare class ContainerLockedError extends Error {
+    constructor(message?: string);
+}
+
+declare class NotImplementedError extends Error {
+    constructor(provider: string);
+}
+
+declare class TypeBoxError extends Error {
+    readonly value: ValueError;
+    constructor(value: ValueError);
+}
+
+interface EventEmitterItem<T extends object> {
+    name: keyof T;
+    handler: (arg: any) => Async<void>;
+}
+declare class EventEmitter<T extends object> {
+    protected events: EventEmitterItem<T>[];
+    /**
+     *
+     * @param name
+     * @param handler
+     */
+    on<Key extends keyof T>(name: Key, handler: (arg: T[Key]) => void): () => void;
+    /**
+     *
+     * @param name
+     * @param data
+     */
+    emit<Key extends keyof T>(name: Key, data: T[Key]): Promise<void>;
+}
+
+declare class TypeProvider {
+    static DEFAULT_STRING_MAX_LENGTH: number;
+    static DEFAULT_LONG_STRING_MAX_LENGTH: number;
+    static DEFAULT_RICH_STRING_MAX_LENGTH: number;
+    static DEFAULT_ARRAY_MAX_ITEMS: number;
+    static FormatRegistry: typeof FormatRegistry;
+    Type: TypeBox.JavaScriptTypeBuilder;
+    any: (options?: SchemaOptions) => TypeBox.TAny;
+    void: (options?: SchemaOptions) => TypeBox.TVoid;
+    undefined: (options?: SchemaOptions) => TypeBox.TUndefined;
+    record: <Key extends TSchema, Value extends TSchema>(key: Key, value: Value, options?: ObjectOptions) => TypeBox.TRecordOrObject<Key, Value>;
+    omit: {
+        <Type extends TSchema, Key extends PropertyKey[]>(type: Type, key: readonly [...Key], options?: SchemaOptions): TypeBox.TOmit<Type, Key>;
+        <Type extends TSchema, Key extends TSchema>(type: Type, key: Key, options?: SchemaOptions): TypeBox.TOmit<Type, Key>;
+    };
+    union: <Types extends TSchema[]>(types: [...Types], options?: SchemaOptions) => Union<Types>;
+    partial: {
+        <MappedResult extends TypeBox.TMappedResult>(type: MappedResult, options?: SchemaOptions): TypeBox.TPartialFromMappedResult<MappedResult>;
+        <Type extends TSchema>(type: Type, options?: SchemaOptions): TypeBox.TPartial<Type>;
+    };
+    composite: <T extends TSchema[]>(schemas: [...T], options?: ObjectOptions) => TypeBox.TComposite<T>;
+    pick: {
+        <Type extends TSchema, Key extends PropertyKey[]>(type: Type, key: readonly [...Key], options?: SchemaOptions): TypeBox.TPick<Type, Key>;
+        <Type extends TSchema, Key extends TSchema>(type: Type, key: Key, options?: SchemaOptions): TypeBox.TPick<Type, Key>;
+    };
+    clean: typeof TypeBoxValue.Clean;
+    /**
+     * Create a schema for an object.
+     *
+     * @param properties The properties of the object.
+     * @param options The options for the object.
+     */
+    object: <T extends TProperties>(properties: T, options?: ObjectOptions) => TObject<T>;
+    /**
+     * Create a schema for an array.
+     *
+     * @param schema
+     * @param options
+     */
+    array: <T extends TSchema>(schema: T, options?: ArrayOptions) => TArray<T>;
+    /**
+     * Create a schema for a string.
+     *
+     * @param options
+     */
+    string: (options?: AlephaStringOptions) => TString;
+    /**
+     * Create a schema for a JSON object.
+     *
+     * @param options
+     */
+    json: (options?: SchemaOptions) => TypeBox.TRecord<TString, TypeBox.TAny>;
+    /**
+     * Create a schema for a boolean.
+     *
+     * @param options
+     */
+    boolean: (options?: SchemaOptions) => TBoolean;
+    /**
+     * Create a schema for a number.
+     *
+     * @param options
+     */
+    number: (options?: NumberOptions) => TNumber;
+    /**
+     * Create a schema for an unsigned 8-bit integer.
+     *
+     * @param options
+     */
+    uchar: (options?: IntegerOptions) => TInteger;
+    /**
+     * Create a schema for an unsigned 32-bit integer.
+     *
+     * @param options
+     */
+    uint: (options?: IntegerOptions) => TNumber;
+    /**
+     * Create a schema for a signed 32-bit integer.
+     *
+     * @param options
+     */
+    int: (options?: IntegerOptions) => TInteger;
+    /**
+     * Make a schema optional.
+     *
+     * @param schema The schema to make optional.
+     */
+    optional: <T extends TSchema>(schema: T) => TOptionalWithFlag<T, true>;
+    /**
+     * Nullify all properties of a schema.
+     *
+     * @param schema The schema to nullify.
+     * @param options The options for the schema.
+     */
+    nullify: <T extends TSchema>(schema: T, options?: ObjectOptions) => TObject<TypeBox.Evaluate<TypeBox.TMappedFunctionReturnType<TypeBox.TIndexPropertyKeys<TypeBox.TKeyOf<T>>, TypeBox.TUnion<[TNull, TypeBox.TMappedResult<TypeBox.Evaluate<TypeBox.TIndexPropertyKeys<TypeBox.TKeyOf<T>> extends infer T_1 ? T_1 extends TypeBox.TIndexPropertyKeys<TypeBox.TKeyOf<T>> ? T_1 extends [infer Left extends PropertyKey, ...infer Right extends PropertyKey[]] ? Right extends [infer Left extends PropertyKey, ...infer Right extends PropertyKey[]] ? Right extends [infer Left extends PropertyKey, ...infer Right extends PropertyKey[]] ? Right extends [infer Left extends PropertyKey, ...infer Right extends PropertyKey[]] ? Right extends [infer Left extends PropertyKey, ...infer Right extends PropertyKey[]] ? Right extends [infer Left extends PropertyKey, ...infer Right extends PropertyKey[]] ? Right extends [infer Left extends PropertyKey, ...infer Right extends PropertyKey[]] ? Right extends [infer Left extends PropertyKey, ...infer Right extends PropertyKey[]] ? Right extends [infer Left extends PropertyKey, ...infer Right extends PropertyKey[]] ? Right extends [infer Left extends PropertyKey, ...infer Right extends PropertyKey[]] ? Right extends [infer Left extends PropertyKey, ...infer Right extends PropertyKey[]] ? /*elided*/ any : { [_ in Left]: TypeBox.Assert<TypeBox.TIndexFromPropertyKey<T, Left>, TSchema>; } : { [_ in Left]: TypeBox.Assert<TypeBox.TIndexFromPropertyKey<T, Left>, TSchema>; } : { [_ in Left]: TypeBox.Assert<TypeBox.TIndexFromPropertyKey<T, Left>, TSchema>; } : { [_ in Left]: TypeBox.Assert<TypeBox.TIndexFromPropertyKey<T, Left>, TSchema>; } : { [_ in Left]: TypeBox.Assert<TypeBox.TIndexFromPropertyKey<T, Left>, TSchema>; } : { [_ in Left]: TypeBox.Assert<TypeBox.TIndexFromPropertyKey<T, Left>, TSchema>; } : { [_ in Left]: TypeBox.Assert<TypeBox.TIndexFromPropertyKey<T, Left>, TSchema>; } : { [_ in Left]: TypeBox.Assert<TypeBox.TIndexFromPropertyKey<T, Left>, TSchema>; } : { [_ in Left]: TypeBox.Assert<TypeBox.TIndexFromPropertyKey<T, Left>, TSchema>; } : { [_ in Left]: TypeBox.Assert<TypeBox.TIndexFromPropertyKey<T, Left>, TSchema>; } : {} : never : never>>]>, {}>>>;
+    /**
+     * Make a schema nullable.
+     *
+     * @param schema The schema to make nullable.
+     * @param options The options for the schema.
+     */
+    nullable: <T extends TSchema>(schema: T, options?: ObjectOptions) => Union<[TNull, T]>;
+    /**
+     * Map a schema to another schema.
+     *
+     * @param schema The schema to map.
+     * @param operations The operations to perform on the schema.
+     * @param options The options for the schema.
+     * @returns The mapped schema.
+     */
+    map: <T extends TObject | TIntersect, Omit extends (keyof T["properties"])[], Optional extends (keyof T["properties"])[]>(schema: T, operations: {
+        omit: readonly [...Omit];
+        optional: [...Optional];
+    }, options?: ObjectOptions) => TObject<TypeBox.Evaluate<TypeBox.TSetDistinct<[...TypeBox.TKeyOfPropertyKeys<TypeBox.TOmit<T, [...Omit, ...Optional], T extends TypeBox.TRef<string> ? true : false, [...Omit, ...Optional] extends infer T_1 ? T_1 extends [...Omit, ...Optional] ? T_1 extends TypeBox.TRef<string> ? true : false : never : never>>, ...TypeBox.TKeyOfPropertyKeys<TypeBox.TPartial<TypeBox.TPick<T, Optional, T extends TypeBox.TRef<string> ? true : false, Optional extends TypeBox.TRef<string> ? true : false>>>], []> extends infer T_2 ? T_2 extends TypeBox.TSetDistinct<[...TypeBox.TKeyOfPropertyKeys<TypeBox.TOmit<T, [...Omit, ...Optional], T extends TypeBox.TRef<string> ? true : false, [...Omit, ...Optional] extends infer T_53 ? T_53 extends [...Omit, ...Optional] ? T_53 extends TypeBox.TRef<string> ? true : false : never : never>>, ...TypeBox.TKeyOfPropertyKeys<TypeBox.TPartial<TypeBox.TPick<T, Optional, T extends TypeBox.TRef<string> ? true : false, Optional extends TypeBox.TRef<string> ? true : false>>>], []> ? T_2 extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? R extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? R extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? R extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? R extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? R extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? R extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? R extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? R extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? R extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? R extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? /*elided*/ any : { [_ in L]: TypeBox.TIntersectEvaluated<TypeBox.Assert<TypeBox.TIndexFromPropertyKey<TypeBox.TOmit<T, [...Omit, ...Optional], T extends TypeBox.TRef<string> ? true : false, [...Omit, ...Optional] extends infer T_3 ? T_3 extends [...Omit, ...Optional] ? T_3 extends TypeBox.TRef<string> ? true : false : never : never>, L>, TSchema> extends infer T_4 ? T_4 extends TypeBox.Assert<TypeBox.TIndexFromPropertyKey<TypeBox.TOmit<T, [...Omit, ...Optional], T extends TypeBox.TRef<string> ? true : false, [...Omit, ...Optional] extends infer T_7 ? T_7 extends [...Omit, ...Optional] ? T_7 extends TypeBox.TRef<string> ? true : false : never : never>, L>, TSchema> ? T_4 extends TypeBox.TNever ? TypeBox.Assert<TypeBox.TIndexFromPropertyKey<TypeBox.TPartial<TypeBox.TPick<T, Optional, T extends TypeBox.TRef<string> ? true : false, Optional extends TypeBox.TRef<string> ? true : false>>, L>, TSchema> extends infer T_5 ? T_5 extends TypeBox.Assert<TypeBox.TIndexFromPropertyKey<TypeBox.TPartial<TypeBox.TPick<T, Optional, T extends TypeBox.TRef<string> ? true : false, Optional extends TypeBox.TRef<string> ? true : false>>, L>, TSchema> ? T_5 extends TypeBox.TNever ? [] : [T_5] : never : never : TypeBox.Assert<TypeBox.TIndexFromPropertyKey<TypeBox.TPartial<TypeBox.TPick<T, Optional, T extends TypeBox.TRef<string> ? true : false, Optional extends TypeBox.TRef<string> ? true : false>>, L>, TSchema> extends infer T_6 ? T_6 extends TypeBox.Assert<TypeBox.TIndexFromPropertyKey<TypeBox.TPartial<TypeBox.TPick<T, Optional, T extends TypeBox.TRef<string> ? true : false, Optional extends TypeBox.TRef<string> ? true : false>>, L>, TSchema> ? T_6 extends TypeBox.TNever ? [T_4] : [T_4, T_6] : never : never : never : never>; } : { [_ in L]: TypeBox.TIntersectEvaluated<TypeBox.Assert<TypeBox.TIndexFromPropertyKey<TypeBox.TOmit<T, [...Omit, ...Optional], T extends TypeBox.TRef<string> ? true : false, [...Omit, ...Optional] extends infer T_8 ? T_8 extends [...Omit, ...Optional] ? T_8 extends TypeBox.TRef<string> ? true : false : never : never>, L>, TSchema> extends infer T_9 ? T_9 extends TypeBox.Assert<TypeBox.TIndexFromPropertyKey<TypeBox.TOmit<T, [...Omit, ...Optional], T extends TypeBox.TRef<string> ? true : false, [...Omit, ...Optional] extends infer T_12 ? T_12 extends [...Omit, ...Optional] ? T_12 extends TypeBox.TRef<string> ? true : false : never : never>, L>, TSchema> ? T_9 extends TypeBox.TNever ? TypeBox.Assert<TypeBox.TIndexFromPropertyKey<TypeBox.TPartial<TypeBox.TPick<T, Optional, T extends TypeBox.TRef<string> ? true : false, Optional extends TypeBox.TRef<string> ? true : false>>, L>, TSchema> extends infer T_10 ? T_10 extends TypeBox.Assert<TypeBox.TIndexFromPropertyKey<TypeBox.TPartial<TypeBox.TPick<T, Optional, T extends TypeBox.TRef<string> ? true : false, Optional extends TypeBox.TRef<string> ? true : false>>, L>, TSchema> ? T_10 extends TypeBox.TNever ? [] : [T_10] : never : never : TypeBox.Assert<TypeBox.TIndexFromPropertyKey<TypeBox.TPartial<TypeBox.TPick<T, Optional, T extends TypeBox.TRef<string> ? true : false, Optional extends TypeBox.TRef<string> ? true : false>>, L>, TSchema> extends infer T_11 ? T_11 extends TypeBox.Assert<TypeBox.TIndexFromPropertyKey<TypeBox.TPartial<TypeBox.TPick<T, Optional, T extends TypeBox.TRef<string> ? true : false, Optional extends TypeBox.TRef<string> ? true : false>>, L>, TSchema> ? T_11 extends TypeBox.TNever ? [T_9] : [T_9, T_11] : never : never : never : never>; } : { [_ in L]: TypeBox.TIntersectEvaluated<TypeBox.Assert<TypeBox.TIndexFromPropertyKey<TypeBox.TOmit<T, [...Omit, ...Optional], T extends TypeBox.TRef<string> ? true : false, [...Omit, ...Optional] extends infer T_13 ? T_13 extends [...Omit, ...Optional] ? T_13 extends TypeBox.TRef<string> ? true : false : never : never>, L>, TSchema> extends infer T_14 ? T_14 extends TypeBox.Assert<TypeBox.TIndexFromPropertyKey<TypeBox.TOmit<T, [...Omit, ...Optional], T extends TypeBox.TRef<string> ? true : false, [...Omit, ...Optional] extends infer T_17 ? T_17 extends [...Omit, ...Optional] ? T_17 extends TypeBox.TRef<string> ? true : false : never : never>, L>, TSchema> ? T_14 extends TypeBox.TNever ? TypeBox.Assert<TypeBox.TIndexFromPropertyKey<TypeBox.TPartial<TypeBox.TPick<T, Optional, T extends TypeBox.TRef<string> ? true : false, Optional extends TypeBox.TRef<string> ? true : false>>, L>, TSchema> extends infer T_15 ? T_15 extends TypeBox.Assert<TypeBox.TIndexFromPropertyKey<TypeBox.TPartial<TypeBox.TPick<T, Optional, T extends TypeBox.TRef<string> ? true : false, Optional extends TypeBox.TRef<string> ? true : false>>, L>, TSchema> ? T_15 extends TypeBox.TNever ? [] : [T_15] : never : never : TypeBox.Assert<TypeBox.TIndexFromPropertyKey<TypeBox.TPartial<TypeBox.TPick<T, Optional, T extends TypeBox.TRef<string> ? true : false, Optional extends TypeBox.TRef<string> ? true : false>>, L>, TSchema> extends infer T_16 ? T_16 extends TypeBox.Assert<TypeBox.TIndexFromPropertyKey<TypeBox.TPartial<TypeBox.TPick<T, Optional, T extends TypeBox.TRef<string> ? true : false, Optional extends TypeBox.TRef<string> ? true : false>>, L>, TSchema> ? T_16 extends TypeBox.TNever ? [T_14] : [T_14, T_16] : never : never : never : never>; } : { [_ in L]: TypeBox.TIntersectEvaluated<TypeBox.Assert<TypeBox.TIndexFromPropertyKey<TypeBox.TOmit<T, [...Omit, ...Optional], T extends TypeBox.TRef<string> ? true : false, [...Omit, ...Optional] extends infer T_18 ? T_18 extends [...Omit, ...Optional] ? T_18 extends TypeBox.TRef<string> ? true : false : never : never>, L>, TSchema> extends infer T_19 ? T_19 extends TypeBox.Assert<TypeBox.TIndexFromPropertyKey<TypeBox.TOmit<T, [...Omit, ...Optional], T extends TypeBox.TRef<string> ? true : false, [...Omit, ...Optional] extends infer T_22 ? T_22 extends [...Omit, ...Optional] ? T_22 extends TypeBox.TRef<string> ? true : false : never : never>, L>, TSchema> ? T_19 extends TypeBox.TNever ? TypeBox.Assert<TypeBox.TIndexFromPropertyKey<TypeBox.TPartial<TypeBox.TPick<T, Optional, T extends TypeBox.TRef<string> ? true : false, Optional extends TypeBox.TRef<string> ? true : false>>, L>, TSchema> extends infer T_20 ? T_20 extends TypeBox.Assert<TypeBox.TIndexFromPropertyKey<TypeBox.TPartial<TypeBox.TPick<T, Optional, T extends TypeBox.TRef<string> ? true : false, Optional extends TypeBox.TRef<string> ? true : false>>, L>, TSchema> ? T_20 extends TypeBox.TNever ? [] : [T_20] : never : never : TypeBox.Assert<TypeBox.TIndexFromPropertyKey<TypeBox.TPartial<TypeBox.TPick<T, Optional, T extends TypeBox.TRef<string> ? true : false, Optional extends TypeBox.TRef<string> ? true : false>>, L>, TSchema> extends infer T_21 ? T_21 extends TypeBox.Assert<TypeBox.TIndexFromPropertyKey<TypeBox.TPartial<TypeBox.TPick<T, Optional, T extends TypeBox.TRef<string> ? true : false, Optional extends TypeBox.TRef<string> ? true : false>>, L>, TSchema> ? T_21 extends TypeBox.TNever ? [T_19] : [T_19, T_21] : never : never : never : never>; } : { [_ in L]: TypeBox.TIntersectEvaluated<TypeBox.Assert<TypeBox.TIndexFromPropertyKey<TypeBox.TOmit<T, [...Omit, ...Optional], T extends TypeBox.TRef<string> ? true : false, [...Omit, ...Optional] extends infer T_23 ? T_23 extends [...Omit, ...Optional] ? T_23 extends TypeBox.TRef<string> ? true : false : never : never>, L>, TSchema> extends infer T_24 ? T_24 extends TypeBox.Assert<TypeBox.TIndexFromPropertyKey<TypeBox.TOmit<T, [...Omit, ...Optional], T extends TypeBox.TRef<string> ? true : false, [...Omit, ...Optional] extends infer T_27 ? T_27 extends [...Omit, ...Optional] ? T_27 extends TypeBox.TRef<string> ? true : false : never : never>, L>, TSchema> ? T_24 extends TypeBox.TNever ? TypeBox.Assert<TypeBox.TIndexFromPropertyKey<TypeBox.TPartial<TypeBox.TPick<T, Optional, T extends TypeBox.TRef<string> ? true : false, Optional extends TypeBox.TRef<string> ? true : false>>, L>, TSchema> extends infer T_25 ? T_25 extends TypeBox.Assert<TypeBox.TIndexFromPropertyKey<TypeBox.TPartial<TypeBox.TPick<T, Optional, T extends TypeBox.TRef<string> ? true : false, Optional extends TypeBox.TRef<string> ? true : false>>, L>, TSchema> ? T_25 extends TypeBox.TNever ? [] : [T_25] : never : never : TypeBox.Assert<TypeBox.TIndexFromPropertyKey<TypeBox.TPartial<TypeBox.TPick<T, Optional, T extends TypeBox.TRef<string> ? true : false, Optional extends TypeBox.TRef<string> ? true : false>>, L>, TSchema> extends infer T_26 ? T_26 extends TypeBox.Assert<TypeBox.TIndexFromPropertyKey<TypeBox.TPartial<TypeBox.TPick<T, Optional, T extends TypeBox.TRef<string> ? true : false, Optional extends TypeBox.TRef<string> ? true : false>>, L>, TSchema> ? T_26 extends TypeBox.TNever ? [T_24] : [T_24, T_26] : never : never : never : never>; } : { [_ in L]: TypeBox.TIntersectEvaluated<TypeBox.Assert<TypeBox.TIndexFromPropertyKey<TypeBox.TOmit<T, [...Omit, ...Optional], T extends TypeBox.TRef<string> ? true : false, [...Omit, ...Optional] extends infer T_28 ? T_28 extends [...Omit, ...Optional] ? T_28 extends TypeBox.TRef<string> ? true : false : never : never>, L>, TSchema> extends infer T_29 ? T_29 extends TypeBox.Assert<TypeBox.TIndexFromPropertyKey<TypeBox.TOmit<T, [...Omit, ...Optional], T extends TypeBox.TRef<string> ? true : false, [...Omit, ...Optional] extends infer T_32 ? T_32 extends [...Omit, ...Optional] ? T_32 extends TypeBox.TRef<string> ? true : false : never : never>, L>, TSchema> ? T_29 extends TypeBox.TNever ? TypeBox.Assert<TypeBox.TIndexFromPropertyKey<TypeBox.TPartial<TypeBox.TPick<T, Optional, T extends TypeBox.TRef<string> ? true : false, Optional extends TypeBox.TRef<string> ? true : false>>, L>, TSchema> extends infer T_30 ? T_30 extends TypeBox.Assert<TypeBox.TIndexFromPropertyKey<TypeBox.TPartial<TypeBox.TPick<T, Optional, T extends TypeBox.TRef<string> ? true : false, Optional extends TypeBox.TRef<string> ? true : false>>, L>, TSchema> ? T_30 extends TypeBox.TNever ? [] : [T_30] : never : never : TypeBox.Assert<TypeBox.TIndexFromPropertyKey<TypeBox.TPartial<TypeBox.TPick<T, Optional, T extends TypeBox.TRef<string> ? true : false, Optional extends TypeBox.TRef<string> ? true : false>>, L>, TSchema> extends infer T_31 ? T_31 extends TypeBox.Assert<TypeBox.TIndexFromPropertyKey<TypeBox.TPartial<TypeBox.TPick<T, Optional, T extends TypeBox.TRef<string> ? true : false, Optional extends TypeBox.TRef<string> ? true : false>>, L>, TSchema> ? T_31 extends TypeBox.TNever ? [T_29] : [T_29, T_31] : never : never : never : never>; } : { [_ in L]: TypeBox.TIntersectEvaluated<TypeBox.Assert<TypeBox.TIndexFromPropertyKey<TypeBox.TOmit<T, [...Omit, ...Optional], T extends TypeBox.TRef<string> ? true : false, [...Omit, ...Optional] extends infer T_33 ? T_33 extends [...Omit, ...Optional] ? T_33 extends TypeBox.TRef<string> ? true : false : never : never>, L>, TSchema> extends infer T_34 ? T_34 extends TypeBox.Assert<TypeBox.TIndexFromPropertyKey<TypeBox.TOmit<T, [...Omit, ...Optional], T extends TypeBox.TRef<string> ? true : false, [...Omit, ...Optional] extends infer T_37 ? T_37 extends [...Omit, ...Optional] ? T_37 extends TypeBox.TRef<string> ? true : false : never : never>, L>, TSchema> ? T_34 extends TypeBox.TNever ? TypeBox.Assert<TypeBox.TIndexFromPropertyKey<TypeBox.TPartial<TypeBox.TPick<T, Optional, T extends TypeBox.TRef<string> ? true : false, Optional extends TypeBox.TRef<string> ? true : false>>, L>, TSchema> extends infer T_35 ? T_35 extends TypeBox.Assert<TypeBox.TIndexFromPropertyKey<TypeBox.TPartial<TypeBox.TPick<T, Optional, T extends TypeBox.TRef<string> ? true : false, Optional extends TypeBox.TRef<string> ? true : false>>, L>, TSchema> ? T_35 extends TypeBox.TNever ? [] : [T_35] : never : never : TypeBox.Assert<TypeBox.TIndexFromPropertyKey<TypeBox.TPartial<TypeBox.TPick<T, Optional, T extends TypeBox.TRef<string> ? true : false, Optional extends TypeBox.TRef<string> ? true : false>>, L>, TSchema> extends infer T_36 ? T_36 extends TypeBox.Assert<TypeBox.TIndexFromPropertyKey<TypeBox.TPartial<TypeBox.TPick<T, Optional, T extends TypeBox.TRef<string> ? true : false, Optional extends TypeBox.TRef<string> ? true : false>>, L>, TSchema> ? T_36 extends TypeBox.TNever ? [T_34] : [T_34, T_36] : never : never : never : never>; } : { [_ in L]: TypeBox.TIntersectEvaluated<TypeBox.Assert<TypeBox.TIndexFromPropertyKey<TypeBox.TOmit<T, [...Omit, ...Optional], T extends TypeBox.TRef<string> ? true : false, [...Omit, ...Optional] extends infer T_38 ? T_38 extends [...Omit, ...Optional] ? T_38 extends TypeBox.TRef<string> ? true : false : never : never>, L>, TSchema> extends infer T_39 ? T_39 extends TypeBox.Assert<TypeBox.TIndexFromPropertyKey<TypeBox.TOmit<T, [...Omit, ...Optional], T extends TypeBox.TRef<string> ? true : false, [...Omit, ...Optional] extends infer T_42 ? T_42 extends [...Omit, ...Optional] ? T_42 extends TypeBox.TRef<string> ? true : false : never : never>, L>, TSchema> ? T_39 extends TypeBox.TNever ? TypeBox.Assert<TypeBox.TIndexFromPropertyKey<TypeBox.TPartial<TypeBox.TPick<T, Optional, T extends TypeBox.TRef<string> ? true : false, Optional extends TypeBox.TRef<string> ? true : false>>, L>, TSchema> extends infer T_40 ? T_40 extends TypeBox.Assert<TypeBox.TIndexFromPropertyKey<TypeBox.TPartial<TypeBox.TPick<T, Optional, T extends TypeBox.TRef<string> ? true : false, Optional extends TypeBox.TRef<string> ? true : false>>, L>, TSchema> ? T_40 extends TypeBox.TNever ? [] : [T_40] : never : never : TypeBox.Assert<TypeBox.TIndexFromPropertyKey<TypeBox.TPartial<TypeBox.TPick<T, Optional, T extends TypeBox.TRef<string> ? true : false, Optional extends TypeBox.TRef<string> ? true : false>>, L>, TSchema> extends infer T_41 ? T_41 extends TypeBox.Assert<TypeBox.TIndexFromPropertyKey<TypeBox.TPartial<TypeBox.TPick<T, Optional, T extends TypeBox.TRef<string> ? true : false, Optional extends TypeBox.TRef<string> ? true : false>>, L>, TSchema> ? T_41 extends TypeBox.TNever ? [T_39] : [T_39, T_41] : never : never : never : never>; } : { [_ in L]: TypeBox.TIntersectEvaluated<TypeBox.Assert<TypeBox.TIndexFromPropertyKey<TypeBox.TOmit<T, [...Omit, ...Optional], T extends TypeBox.TRef<string> ? true : false, [...Omit, ...Optional] extends infer T_43 ? T_43 extends [...Omit, ...Optional] ? T_43 extends TypeBox.TRef<string> ? true : false : never : never>, L>, TSchema> extends infer T_44 ? T_44 extends TypeBox.Assert<TypeBox.TIndexFromPropertyKey<TypeBox.TOmit<T, [...Omit, ...Optional], T extends TypeBox.TRef<string> ? true : false, [...Omit, ...Optional] extends infer T_47 ? T_47 extends [...Omit, ...Optional] ? T_47 extends TypeBox.TRef<string> ? true : false : never : never>, L>, TSchema> ? T_44 extends TypeBox.TNever ? TypeBox.Assert<TypeBox.TIndexFromPropertyKey<TypeBox.TPartial<TypeBox.TPick<T, Optional, T extends TypeBox.TRef<string> ? true : false, Optional extends TypeBox.TRef<string> ? true : false>>, L>, TSchema> extends infer T_45 ? T_45 extends TypeBox.Assert<TypeBox.TIndexFromPropertyKey<TypeBox.TPartial<TypeBox.TPick<T, Optional, T extends TypeBox.TRef<string> ? true : false, Optional extends TypeBox.TRef<string> ? true : false>>, L>, TSchema> ? T_45 extends TypeBox.TNever ? [] : [T_45] : never : never : TypeBox.Assert<TypeBox.TIndexFromPropertyKey<TypeBox.TPartial<TypeBox.TPick<T, Optional, T extends TypeBox.TRef<string> ? true : false, Optional extends TypeBox.TRef<string> ? true : false>>, L>, TSchema> extends infer T_46 ? T_46 extends TypeBox.Assert<TypeBox.TIndexFromPropertyKey<TypeBox.TPartial<TypeBox.TPick<T, Optional, T extends TypeBox.TRef<string> ? true : false, Optional extends TypeBox.TRef<string> ? true : false>>, L>, TSchema> ? T_46 extends TypeBox.TNever ? [T_44] : [T_44, T_46] : never : never : never : never>; } : { [_ in L]: TypeBox.TIntersectEvaluated<TypeBox.Assert<TypeBox.TIndexFromPropertyKey<TypeBox.TOmit<T, [...Omit, ...Optional], T extends TypeBox.TRef<string> ? true : false, [...Omit, ...Optional] extends infer T_48 ? T_48 extends [...Omit, ...Optional] ? T_48 extends TypeBox.TRef<string> ? true : false : never : never>, L>, TSchema> extends infer T_49 ? T_49 extends TypeBox.Assert<TypeBox.TIndexFromPropertyKey<TypeBox.TOmit<T, [...Omit, ...Optional], T extends TypeBox.TRef<string> ? true : false, [...Omit, ...Optional] extends infer T_52 ? T_52 extends [...Omit, ...Optional] ? T_52 extends TypeBox.TRef<string> ? true : false : never : never>, L>, TSchema> ? T_49 extends TypeBox.TNever ? TypeBox.Assert<TypeBox.TIndexFromPropertyKey<TypeBox.TPartial<TypeBox.TPick<T, Optional, T extends TypeBox.TRef<string> ? true : false, Optional extends TypeBox.TRef<string> ? true : false>>, L>, TSchema> extends infer T_50 ? T_50 extends TypeBox.Assert<TypeBox.TIndexFromPropertyKey<TypeBox.TPartial<TypeBox.TPick<T, Optional, T extends TypeBox.TRef<string> ? true : false, Optional extends TypeBox.TRef<string> ? true : false>>, L>, TSchema> ? T_50 extends TypeBox.TNever ? [] : [T_50] : never : never : TypeBox.Assert<TypeBox.TIndexFromPropertyKey<TypeBox.TPartial<TypeBox.TPick<T, Optional, T extends TypeBox.TRef<string> ? true : false, Optional extends TypeBox.TRef<string> ? true : false>>, L>, TSchema> extends infer T_51 ? T_51 extends TypeBox.Assert<TypeBox.TIndexFromPropertyKey<TypeBox.TPartial<TypeBox.TPick<T, Optional, T extends TypeBox.TRef<string> ? true : false, Optional extends TypeBox.TRef<string> ? true : false>>, L>, TSchema> ? T_51 extends TypeBox.TNever ? [T_49] : [T_49, T_51] : never : never : never : never>; } : {} : never : never>>;
+    /**
+     * Create a schema for a string enum.
+     *
+     * @param values
+     * @param options
+     */
+    enum: <T extends string[]>(values: [...T], options?: StringOptions) => TUnsafe<T[number]>;
+    /**
+     * Create a schema for a string enum e.g. LIKE_THIS.
+     *
+     * @param options
+     */
+    snakeCase: (options?: StringOptions) => TString;
+    /**
+     * Create a schema for an object with a value and label.
+     *
+     * @param options
+     */
+    valueLabel: (options?: ObjectOptions) => TObject<{
+        value: TString;
+        label: TString;
+        description: TypeBox.TOptional<TString>;
+    }>;
+    /**
+     * Create a schema for a datetime.
+     *
+     * @param options The options for the date.
+     */
+    datetime: (options?: StringOptions) => TString;
+    /**
+     * Create a schema for a date.
+     *
+     * @param options
+     */
+    date: (options?: StringOptions) => TString;
+    /**
+     * Create a schema for uuid.
+     *
+     * @param options The options for the duration.
+     */
+    uuid: (options?: StringOptions) => TString;
+    /**
+     *
+     *
+     * @param kind
+     * @param options
+     */
+    unsafe: <T>(kind: string, options?: UnsafeOptions) => TUnsafe<T>;
+    file: (options?: {
+        max?: number;
+    }) => TFile;
+    stream: () => TStream;
+}
+interface FileLike {
+    name: string;
+    type: string;
+    size: number;
+    lastModified: number;
+    stream(): StreamLike;
+    arrayBuffer(): Promise<ArrayBuffer>;
+    text(): Promise<string>;
+    filepath?: string;
+}
+type TFile = TUnsafe<FileLike>;
+type StreamLike = ReadableStream | ReadableStream$1 | Readable;
+type TStream = TUnsafe<StreamLike>;
+declare const t: TypeProvider;
+declare const isTypeFile: (value: TSchema) => value is TFile;
+declare const isFileLike: (value: any) => value is FileLike;
+declare const isTypeStream: (value: TSchema) => value is TStream;
+type TextLength = "short" | "long" | "rich";
+interface AlephaStringOptions extends StringOptions {
+    size?: TextLength;
+}
+declare const isUUID: (value: string) => boolean;
+
+declare const run: (arg: Alepha | Class | ((env?: Env) => Alepha), opts?: {
+    env?: Env;
+    configure?: (alepha: Alepha) => Async<void>;
+    ready?: (alepha: Alepha) => Async<void>;
+}) => Alepha;
+
+export { $cursor, $hook, $inject, $logger, $retry, Alepha, type AlephaStringOptions, AppNotStartedError, type Async, type AsyncFn, type AsyncLocalStorageData, AsyncLocalStorageProvider, COLORS, CircularDependencyError, type Class, type ClassEntry, type ClassProvider, type ClassSwap, ContainerLockedError, type CursorDescriptor, type Descriptor, type DescriptorIdentifier, type DescriptorItem, type Env, EventEmitter, type EventEmitterItem, EventEmitterLike, type FileLike, type Hook, type HookDescriptor, type HookOptions, type Hooks, KIND, LEVEL_COLORS, type LogLevel, Logger, type LoggerEnv, type LoggerOptions, MockLogger, type MockLoggerStore, NotImplementedError, OPTIONS, PROVIDER, type PromiseFn, type RetryDescriptorOptions, type State, type StreamLike, type TFile, type TStream, type TextLength, TypeBoxError, TypeProvider, __alephaRef, __bind, __descriptor, descriptorEvents, isDescriptorValue, isFileLike, isTypeFile, isTypeStream, isUUID, run, t };