@orieljs/framework 0.1.0-alpha.0

package/dist/index.d.ts

@@ -0,0 +1,799 @@
+/** A typed, runtime-unique key for container bindings. */
+interface Token$3<T> {
+    readonly id: symbol;
+    readonly description: string;
+    /** Phantom field: only carries T at the type level. Never set at runtime. */
+    readonly __type?: T;
+}
+type Class$2<T> = abstract new (...args: any[]) => T;
+type Abstract$2<T> = Token$3<T> | Class$2<T>;
+type Factory$2<T> = (container: Container$4) => T;
+type Concrete$2<T> = Factory$2<T> | (new () => T);
+interface Container$4 {
+    /** New instance on every make(). A class with no concrete binds to itself (constructed with no args). Root only; throws on a scope. */
+    bind<T>(abstract: Abstract$2<T>, concrete?: Concrete$2<T>): void;
+    /** One instance for the life of this container and its scopes. Root only; throws on a scope. */
+    singleton<T>(abstract: Abstract$2<T>, concrete?: Concrete$2<T>): void;
+    /** One instance per scope (e.g. per HTTP request or queue job). Root only; throws on a scope. */
+    scoped<T>(abstract: Abstract$2<T>, concrete?: Concrete$2<T>): void;
+    /** Register an existing object as a shared instance. Returns it. On a scope it stays local to that scope. */
+    instance<T>(abstract: Abstract$2<T>, instance: T): T;
+    /** Resolve. Unbound classes are constructed with `new Class()`. Unbound tokens throw BindingResolutionError. */
+    make<T>(abstract: Abstract$2<T>): T;
+    bound(abstract: Abstract$2<unknown>): boolean;
+    resolved(abstract: Abstract$2<unknown>): boolean;
+    /** Decorate or replace an instance each time it's resolved (applied before resolving callbacks). Root only; throws on a scope. */
+    extend<T>(abstract: Abstract$2<T>, extender: (instance: T, container: Container$4) => T): void;
+    /** Called after each resolution of the abstract. Root only; throws on a scope. */
+    resolving<T>(abstract: Abstract$2<T>, callback: (instance: T, container: Container$4) => void): void;
+    forgetInstance(abstract: Abstract$2<unknown>): void;
+    /** A child container: shares bindings and singletons with its parent, and has its own scoped instances. Bindings can't be registered on it. */
+    createScope(): Container$4;
+    /** Run fn with this container as the "current" one for inject(), helpers and facades (AsyncLocalStorage). */
+    run<R>(fn: () => R): R;
+}
+declare const Container$4: Token$3<Container$4>;
+
+type ErrorKind = 'Http' | 'ModelNotFound' | 'Validation' | 'Authentication' | 'Authorization' | 'TokenMismatch' | 'BindingResolution' | 'CircularDependency' | 'ContainerNotAvailable';
+/** Every error thrown by the framework implements this. The exception handler switches on `kind`. */
+interface OrielError extends Error {
+    readonly kind: ErrorKind;
+    /** HTTP status the error should render as, when relevant. */
+    readonly status?: number;
+    readonly headers?: Record<string, string>;
+}
+
+type Key$1 = unknown;
+type Lifetime$1 = 'transient' | 'singleton' | 'scoped';
+interface Binding$1 {
+    lifetime: Lifetime$1;
+    factory: Factory$2<unknown>;
+}
+type Extender$1 = (instance: unknown, c: Container$4) => unknown;
+type Callback$1 = (instance: unknown, c: Container$4) => void;
+interface SharedState$1 {
+    bindings: Map<Key$1, Binding$1>;
+    extenders: Map<Key$1, Extender$1[]>;
+    resolving: Map<Key$1, Callback$1[]>;
+    resolved: Set<Key$1>;
+}
+declare class Container$3 implements Container$4 {
+    #private;
+    static getInstance(): Container$3 | undefined;
+    static setInstance(container: Container$3 | undefined): void;
+    protected readonly shared: SharedState$1;
+    protected readonly root: Container$3;
+    protected readonly parent: Container$3 | undefined;
+    protected readonly local: Map<unknown, unknown>;
+    constructor(parent?: Container$3);
+    bind<T>(abstract: Abstract$2<T>, concrete?: Concrete$2<T>): void;
+    singleton<T>(abstract: Abstract$2<T>, concrete?: Concrete$2<T>): void;
+    scoped<T>(abstract: Abstract$2<T>, concrete?: Concrete$2<T>): void;
+    instance<T>(abstract: Abstract$2<T>, instance: T): T;
+    make<T>(abstract: Abstract$2<T>): T;
+    bound(abstract: Abstract$2<unknown>): boolean;
+    resolved(abstract: Abstract$2<unknown>): boolean;
+    extend<T>(abstract: Abstract$2<T>, extender: (instance: T, container: Container$4) => T): void;
+    resolving<T>(abstract: Abstract$2<T>, callback: (instance: T, container: Container$4) => void): void;
+    forgetInstance(abstract: Abstract$2<unknown>): void;
+    /** Scopes are always plain Containers (never subclasses such as Application). */
+    createScope(): Container$3;
+    run<R>(fn: () => R): R;
+    protected build(abstract: Abstract$2<unknown>, key: Key$1, binding: Binding$1): unknown;
+}
+
+declare class BindingResolutionError extends Error implements OrielError {
+    readonly kind: "BindingResolution";
+    readonly name = "BindingResolutionError";
+}
+declare class CircularDependencyError extends Error implements OrielError {
+    readonly chain: string[];
+    readonly kind: "CircularDependency";
+    readonly name = "CircularDependencyError";
+    constructor(chain: string[]);
+}
+declare class ContainerNotAvailableError extends Error implements OrielError {
+    readonly kind: "ContainerNotAvailable";
+    readonly name = "ContainerNotAvailableError";
+    constructor(what: string);
+}
+
+declare function currentContainer(): Container$4 | undefined;
+declare function inject<T>(abstract: Abstract$2<T>): T;
+
+interface Arrayable<T = unknown> {
+    toArray(): T;
+}
+/** The minimal collection surface contracts rely on (implemented by @orieljs/collections). */
+interface Enumerable<T> extends Iterable<T>, Arrayable<unknown[]> {
+    all(): T[];
+    count(): number;
+    isEmpty(): boolean;
+}
+
+type Operator$1 = '=' | '==' | '===' | '!=' | '!==' | '<>' | '<' | '<=' | '>' | '>=';
+
+type Getter$1<T, V = unknown> = (keyof T & string) | ((item: T) => V);
+declare class Collection$1<T> implements Enumerable<T> {
+    protected readonly items: T[];
+    constructor(items?: Iterable<T>);
+    static make<T>(items?: Iterable<T>): Collection$1<T>;
+    /** Laravel semantics: callback receives 1..n. */
+    static times<T>(count: number, callback: (index: number) => T): Collection$1<T>;
+    [Symbol.iterator](): Iterator<T>;
+    all(): T[];
+    count(): number;
+    isEmpty(): boolean;
+    isNotEmpty(): boolean;
+    toArray(): unknown[];
+    toJSON(): T[];
+    toJson(): string;
+    map<U>(callback: (item: T, index: number) => U): Collection$1<U>;
+    flatMap<U>(callback: (item: T, index: number) => U | U[] | Collection$1<U>): Collection$1<U>;
+    filter(callback?: (item: T, index: number) => unknown): Collection$1<T>;
+    reject(callback: (item: T, index: number) => unknown): Collection$1<T>;
+    /** Return false from the callback to stop. */
+    each(callback: (item: T, index: number) => unknown): this;
+    reduce<U>(callback: (carry: U, item: T, index: number) => U, initial: U): U;
+    first(): T | undefined;
+    first<D = undefined>(callback: (item: T, index: number) => unknown, defaultValue?: D): T | D;
+    last(): T | undefined;
+    last<D = undefined>(callback: (item: T, index: number) => unknown, defaultValue?: D): T | D;
+    where(key: Getter$1<T>, value: unknown): Collection$1<T>;
+    where(key: Getter$1<T>, operator: Operator$1, value: unknown): Collection$1<T>;
+    firstWhere(key: Getter$1<T>, value: unknown): T | undefined;
+    firstWhere(key: Getter$1<T>, operator: Operator$1, value: unknown): T | undefined;
+    whereIn(key: Getter$1<T>, values: readonly unknown[]): Collection$1<T>;
+    whereNotIn(key: Getter$1<T>, values: readonly unknown[]): Collection$1<T>;
+    pluck<K extends keyof T & string>(key: K): Collection$1<T[K]>;
+    keyBy(key: Getter$1<T>): Record<string, T>;
+    groupBy(key: Getter$1<T>): Record<string, Collection$1<T>>;
+    mapWithKeys<V>(callback: (item: T, index: number) => readonly [string, V]): Record<string, V>;
+    sortBy(key: Getter$1<T>, direction?: 'asc' | 'desc'): Collection$1<T>;
+    sortByDesc(key: Getter$1<T>): Collection$1<T>;
+    sum(key?: Getter$1<T>): number;
+    avg(key?: Getter$1<T>): number | undefined;
+    min(key?: Getter$1<T>): number | undefined;
+    max(key?: Getter$1<T>): number | undefined;
+    unique(key?: Getter$1<T>): Collection$1<T>;
+    chunk(size: number): Collection$1<Collection$1<T>>;
+    /** Negative count takes from the end. */
+    take(count: number): Collection$1<T>;
+    skip(count: number): Collection$1<T>;
+    slice(offset: number, length?: number): Collection$1<T>;
+    values(): Collection$1<T>;
+    contains(key: keyof T & string, value: unknown): boolean;
+    contains(callback: (item: T) => boolean): boolean;
+    contains(value: unknown): boolean;
+    /** Mutates, like Laravel. */
+    push(...values: T[]): this;
+    concat(values: Iterable<T>): Collection$1<T>;
+    partition(callback: (item: T, index: number) => unknown): [Collection$1<T>, Collection$1<T>];
+    implode(glue: string): string;
+    implode(key: keyof T & string, glue: string): string;
+    when<U = this>(condition: unknown, callback: (collection: this) => U): U | this;
+    pipe<U>(callback: (collection: this) => U): U;
+    tap(callback: (collection: this) => void): this;
+}
+
+type Source<T> = () => AsyncIterable<T> | Iterable<T>;
+/** Pull-based and async: for DB cursors (Model.lazy()) and large files. */
+declare class LazyCollection<T> implements AsyncIterable<T> {
+    private readonly source;
+    constructor(source: Source<T>);
+    static make<T>(source: Source<T>): LazyCollection<T>;
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+    map<U>(callback: (item: T, index: number) => U | Promise<U>): LazyCollection<U>;
+    filter(callback: (item: T, index: number) => unknown): LazyCollection<T>;
+    take(count: number): LazyCollection<T>;
+    chunk(size: number): LazyCollection<Collection$1<T>>;
+    /** Return false from the callback to stop. */
+    each(callback: (item: T, index: number) => unknown): Promise<void>;
+    first(callback?: (item: T) => unknown): Promise<T | undefined>;
+    count(): Promise<number>;
+    collect(): Promise<Collection$1<T>>;
+}
+
+/** A typed, runtime-unique key for container bindings. */
+interface Token$2<T> {
+    readonly id: symbol;
+    readonly description: string;
+    /** Phantom field: only carries T at the type level. Never set at runtime. */
+    readonly __type?: T;
+}
+type Class$1<T> = abstract new (...args: any[]) => T;
+type Abstract$1<T> = Token$2<T> | Class$1<T>;
+type Factory$1<T> = (container: Container$2) => T;
+type Concrete$1<T> = Factory$1<T> | (new () => T);
+interface Container$2 {
+    /** New instance on every make(). A class with no concrete binds to itself (constructed with no args). Root only; throws on a scope. */
+    bind<T>(abstract: Abstract$1<T>, concrete?: Concrete$1<T>): void;
+    /** One instance for the life of this container and its scopes. Root only; throws on a scope. */
+    singleton<T>(abstract: Abstract$1<T>, concrete?: Concrete$1<T>): void;
+    /** One instance per scope (e.g. per HTTP request or queue job). Root only; throws on a scope. */
+    scoped<T>(abstract: Abstract$1<T>, concrete?: Concrete$1<T>): void;
+    /** Register an existing object as a shared instance. Returns it. On a scope it stays local to that scope. */
+    instance<T>(abstract: Abstract$1<T>, instance: T): T;
+    /** Resolve. Unbound classes are constructed with `new Class()`. Unbound tokens throw BindingResolutionError. */
+    make<T>(abstract: Abstract$1<T>): T;
+    bound(abstract: Abstract$1<unknown>): boolean;
+    resolved(abstract: Abstract$1<unknown>): boolean;
+    /** Decorate or replace an instance each time it's resolved (applied before resolving callbacks). Root only; throws on a scope. */
+    extend<T>(abstract: Abstract$1<T>, extender: (instance: T, container: Container$2) => T): void;
+    /** Called after each resolution of the abstract. Root only; throws on a scope. */
+    resolving<T>(abstract: Abstract$1<T>, callback: (instance: T, container: Container$2) => void): void;
+    forgetInstance(abstract: Abstract$1<unknown>): void;
+    /** A child container: shares bindings and singletons with its parent, and has its own scoped instances. Bindings can't be registered on it. */
+    createScope(): Container$2;
+    /** Run fn with this container as the "current" one for inject(), helpers and facades (AsyncLocalStorage). */
+    run<R>(fn: () => R): R;
+}
+declare const Container$2: Token$2<Container$2>;
+
+interface ServiceProvider$2 {
+    /** Bind things into the container. Synchronous. Don't resolve other services here. */
+    register?(): void;
+    /** Runs after every provider is registered. May be async (e.g. importing route files). */
+    boot?(): void | Promise<void>;
+}
+type ServiceProviderClass$1 = new (app: Application$2) => ServiceProvider$2;
+interface Application$2 extends Container$2 {
+    readonly version: string;
+    basePath(path?: string): string;
+    appPath(path?: string): string;
+    bootstrapPath(path?: string): string;
+    configPath(path?: string): string;
+    databasePath(path?: string): string;
+    publicPath(path?: string): string;
+    resourcePath(path?: string): string;
+    storagePath(path?: string): string;
+    /** With no args returns the environment name. With args returns whether it matches any of them. */
+    environment(): string;
+    environment(...environments: string[]): boolean;
+    isProduction(): boolean;
+    isLocal(): boolean;
+    runningInConsole(): boolean;
+    /** Mark the app as running in the console (the CLI entry point calls this). Defaults to true. */
+    setRunningInConsole(value?: boolean): void;
+    runningUnitTests(): boolean;
+    /** Registers the provider. If the app is already booted, the provider is booted immediately. */
+    register(provider: ServiceProvider$2 | ServiceProviderClass$1): Promise<ServiceProvider$2>;
+    getProviders(): ServiceProvider$2[];
+    boot(): Promise<void>;
+    isBooted(): boolean;
+    booting(callback: (app: Application$2) => void | Promise<void>): void;
+    booted(callback: (app: Application$2) => void | Promise<void>): void;
+    /** Handle one HTTP request in a fresh request scope via the bound HttpKernel. */
+    handle(request: Request): Promise<Response>;
+    /** Register a callback that terminate() runs, in registration order. */
+    terminating(callback: () => void | Promise<void>): void;
+    terminate(): Promise<void>;
+}
+declare const Application$2: Token$2<Application$2>;
+
+interface ConfigRepository$1 {
+    has(key: string): boolean;
+    /** Dot notation: get('database.connections.sqlite.database'). */
+    get<T = unknown>(key: string, defaultValue?: T): T;
+    set(key: string, value: unknown): void;
+    set(values: Record<string, unknown>): void;
+    push(key: string, value: unknown): void;
+    all(): Record<string, unknown>;
+}
+declare const ConfigRepository$1: Token$2<ConfigRepository$1>;
+interface ClassRegistry$1 {
+    /** Registers under `name` (default: cls.name). Throws if the name is already taken by a different class. */
+    register(cls: Class$1<unknown>, name?: string): string;
+    nameOf(cls: Class$1<unknown>): string | undefined;
+    resolve<T = unknown>(name: string): Class$1<T>;
+    has(name: string): boolean;
+}
+declare const ClassRegistry$1: Token$2<ClassRegistry$1>;
+
+type Operator = '=' | '==' | '===' | '!=' | '!==' | '<>' | '<' | '<=' | '>' | '>=';
+
+type Getter<T, V = unknown> = (keyof T & string) | ((item: T) => V);
+declare class Collection<T> implements Enumerable<T> {
+    protected readonly items: T[];
+    constructor(items?: Iterable<T>);
+    static make<T>(items?: Iterable<T>): Collection<T>;
+    /** Laravel semantics: callback receives 1..n. */
+    static times<T>(count: number, callback: (index: number) => T): Collection<T>;
+    [Symbol.iterator](): Iterator<T>;
+    all(): T[];
+    count(): number;
+    isEmpty(): boolean;
+    isNotEmpty(): boolean;
+    toArray(): unknown[];
+    toJSON(): T[];
+    toJson(): string;
+    map<U>(callback: (item: T, index: number) => U): Collection<U>;
+    flatMap<U>(callback: (item: T, index: number) => U | U[] | Collection<U>): Collection<U>;
+    filter(callback?: (item: T, index: number) => unknown): Collection<T>;
+    reject(callback: (item: T, index: number) => unknown): Collection<T>;
+    /** Return false from the callback to stop. */
+    each(callback: (item: T, index: number) => unknown): this;
+    reduce<U>(callback: (carry: U, item: T, index: number) => U, initial: U): U;
+    first(): T | undefined;
+    first<D = undefined>(callback: (item: T, index: number) => unknown, defaultValue?: D): T | D;
+    last(): T | undefined;
+    last<D = undefined>(callback: (item: T, index: number) => unknown, defaultValue?: D): T | D;
+    where(key: Getter<T>, value: unknown): Collection<T>;
+    where(key: Getter<T>, operator: Operator, value: unknown): Collection<T>;
+    firstWhere(key: Getter<T>, value: unknown): T | undefined;
+    firstWhere(key: Getter<T>, operator: Operator, value: unknown): T | undefined;
+    whereIn(key: Getter<T>, values: readonly unknown[]): Collection<T>;
+    whereNotIn(key: Getter<T>, values: readonly unknown[]): Collection<T>;
+    pluck<K extends keyof T & string>(key: K): Collection<T[K]>;
+    keyBy(key: Getter<T>): Record<string, T>;
+    groupBy(key: Getter<T>): Record<string, Collection<T>>;
+    mapWithKeys<V>(callback: (item: T, index: number) => readonly [string, V]): Record<string, V>;
+    sortBy(key: Getter<T>, direction?: 'asc' | 'desc'): Collection<T>;
+    sortByDesc(key: Getter<T>): Collection<T>;
+    sum(key?: Getter<T>): number;
+    avg(key?: Getter<T>): number | undefined;
+    min(key?: Getter<T>): number | undefined;
+    max(key?: Getter<T>): number | undefined;
+    unique(key?: Getter<T>): Collection<T>;
+    chunk(size: number): Collection<Collection<T>>;
+    /** Negative count takes from the end. */
+    take(count: number): Collection<T>;
+    skip(count: number): Collection<T>;
+    slice(offset: number, length?: number): Collection<T>;
+    values(): Collection<T>;
+    contains(key: keyof T & string, value: unknown): boolean;
+    contains(callback: (item: T) => boolean): boolean;
+    contains(value: unknown): boolean;
+    /** Mutates, like Laravel. */
+    push(...values: T[]): this;
+    concat(values: Iterable<T>): Collection<T>;
+    partition(callback: (item: T, index: number) => unknown): [Collection<T>, Collection<T>];
+    implode(glue: string): string;
+    implode(key: keyof T & string, glue: string): string;
+    when<U = this>(condition: unknown, callback: (collection: this) => U): U | this;
+    pipe<U>(callback: (collection: this) => U): U;
+    tap(callback: (collection: this) => void): this;
+}
+declare function collect<T>(items?: Iterable<T>): Collection<T>;
+
+declare const Str: {
+    ucfirst: (v: string) => string;
+    lcfirst: (v: string) => string;
+    studly: (v: string) => string;
+    camel: (v: string) => string;
+    snake: (v: string, delimiter?: string) => string;
+    kebab: (v: string) => string;
+    title: (v: string) => string;
+    slug: (v: string, separator?: string) => string;
+    plural: (v: string, count?: number) => string;
+    singular: (v: string) => string;
+    random: (length?: number) => string;
+    uuid: () => `${string}-${string}-${string}-${string}-${string}`;
+    /** Wildcard match: `*` matches anything; everything else is literal. */
+    is: (pattern: string, value: string) => boolean;
+    startsWith: (v: string, needles: string | string[]) => boolean;
+    endsWith: (v: string, needles: string | string[]) => boolean;
+    contains: (v: string, needles: string | string[]) => boolean;
+    after: (v: string, search: string) => string;
+    afterLast: (v: string, search: string) => string;
+    before: (v: string, search: string) => string;
+    beforeLast: (v: string, search: string) => string;
+    between: (v: string, from: string, to: string) => string;
+    limit: (v: string, limit?: number, end?: string) => string;
+    start: (v: string, prefix: string) => string;
+    finish: (v: string, cap: string) => string;
+};
+
+type Obj = Record<string, unknown>;
+declare const Arr: {
+    get<T = unknown>(target: unknown, key: string | undefined, defaultValue?: T): T;
+    has(target: unknown, key: string): boolean;
+    set(target: Obj, key: string, value: unknown): Obj;
+    forget(target: Obj, key: string): void;
+    dot(target: Obj, prefix?: string): Obj;
+    undot(flat: Obj): Obj;
+    only<T extends Obj>(target: T, keys: string[]): Partial<T>;
+    except<T extends Obj>(target: T, keys: string[]): Partial<T>;
+    wrap<T>(value: T | T[] | null | undefined): T[];
+    first<T, D = undefined>(items: readonly T[], predicate?: (item: T, index: number) => boolean, defaultValue?: D): T | D;
+    last<T, D = undefined>(items: readonly T[], predicate?: (item: T, index: number) => boolean, defaultValue?: D): T | D;
+};
+
+declare abstract class ServiceProvider$1 implements ServiceProvider$2 {
+    protected readonly app: Application$2;
+    constructor(app: Application$2);
+    register(): void;
+    boot(): void | Promise<void>;
+    /** Package defaults under `key`; values the app already set win (shallow merge, like Laravel). */
+    protected mergeConfigFrom(defaults: Record<string, unknown>, key: string): void;
+}
+
+interface FacadeStatics<T> {
+    getFacadeRoot(): T;
+    /** Replace the instance in the current container (used by X.fake()). */
+    swap(instance: T): void;
+}
+type Facade<T, X = object> = T & X & FacadeStatics<T>;
+declare function facade<T extends object, X extends object = object>(abstract: Abstract$1<T>, extras?: X): Facade<T, X>;
+
+declare class ClassRegistry implements ClassRegistry$1 {
+    private readonly byName;
+    private readonly byClass;
+    register(cls: Class$1<unknown>, name?: string): string;
+    nameOf(cls: Class$1<unknown>): string | undefined;
+    resolve<T = unknown>(name: string): Class$1<T>;
+    has(name: string): boolean;
+}
+
+/**
+ * The application, or an abstract resolved from the current container.
+ * Inside a request scope, app().make()/instance()/… act on that scope, so app().make(X) sees scoped services.
+ */
+declare function app(): Application$2;
+declare function app<T>(abstract: Abstract$1<T>): T;
+declare function config(): ConfigRepository$1;
+declare function config(values: Record<string, unknown>): void;
+declare function config<T = unknown>(key: string, defaultValue?: T): T;
+declare const now: () => Date;
+declare const value: <T>(v: T | (() => T)) => T;
+declare function tap<T>(target: T, callback: (target: T) => void): T;
+/** Calls fn up to `times` times (attempt numbers are 1-based). Rethrows the last error, or the first one `when` rejects. */
+declare function retry<T>(times: number, fn: (attempt: number) => T | Promise<T>, sleepMs?: number | ((attempt: number) => number), when?: (error: unknown) => boolean): Promise<T>;
+
+/** A typed, runtime-unique key for container bindings. */
+interface Token$1<T> {
+    readonly id: symbol;
+    readonly description: string;
+    /** Phantom field: only carries T at the type level. Never set at runtime. */
+    readonly __type?: T;
+}
+
+interface ConfigRepository {
+    has(key: string): boolean;
+    /** Dot notation: get('database.connections.sqlite.database'). */
+    get<T = unknown>(key: string, defaultValue?: T): T;
+    set(key: string, value: unknown): void;
+    set(values: Record<string, unknown>): void;
+    push(key: string, value: unknown): void;
+    all(): Record<string, unknown>;
+}
+declare const ConfigRepository: Token$1<ConfigRepository>;
+
+declare class Repository implements ConfigRepository {
+    private readonly items;
+    constructor(items?: Record<string, unknown>);
+    has(key: string): boolean;
+    get<T = unknown>(key: string, defaultValue?: T): T;
+    set(key: string, value: unknown): void;
+    set(values: Record<string, unknown>): void;
+    push(key: string, value: unknown): void;
+    all(): Record<string, unknown>;
+}
+
+declare function env<T = undefined>(key: string, defaultValue?: T | (() => T)): T | string | boolean | null;
+
+/** A typed, runtime-unique key for container bindings. */
+interface Token<T> {
+    readonly id: symbol;
+    readonly description: string;
+    /** Phantom field: only carries T at the type level. Never set at runtime. */
+    readonly __type?: T;
+}
+type Class<T> = abstract new (...args: any[]) => T;
+type Abstract<T> = Token<T> | Class<T>;
+type Factory<T> = (container: Container$1) => T;
+type Concrete<T> = Factory<T> | (new () => T);
+interface Container$1 {
+    /** New instance on every make(). A class with no concrete binds to itself (constructed with no args). Root only; throws on a scope. */
+    bind<T>(abstract: Abstract<T>, concrete?: Concrete<T>): void;
+    /** One instance for the life of this container and its scopes. Root only; throws on a scope. */
+    singleton<T>(abstract: Abstract<T>, concrete?: Concrete<T>): void;
+    /** One instance per scope (e.g. per HTTP request or queue job). Root only; throws on a scope. */
+    scoped<T>(abstract: Abstract<T>, concrete?: Concrete<T>): void;
+    /** Register an existing object as a shared instance. Returns it. On a scope it stays local to that scope. */
+    instance<T>(abstract: Abstract<T>, instance: T): T;
+    /** Resolve. Unbound classes are constructed with `new Class()`. Unbound tokens throw BindingResolutionError. */
+    make<T>(abstract: Abstract<T>): T;
+    bound(abstract: Abstract<unknown>): boolean;
+    resolved(abstract: Abstract<unknown>): boolean;
+    /** Decorate or replace an instance each time it's resolved (applied before resolving callbacks). Root only; throws on a scope. */
+    extend<T>(abstract: Abstract<T>, extender: (instance: T, container: Container$1) => T): void;
+    /** Called after each resolution of the abstract. Root only; throws on a scope. */
+    resolving<T>(abstract: Abstract<T>, callback: (instance: T, container: Container$1) => void): void;
+    forgetInstance(abstract: Abstract<unknown>): void;
+    /** A child container: shares bindings and singletons with its parent, and has its own scoped instances. Bindings can't be registered on it. */
+    createScope(): Container$1;
+    /** Run fn with this container as the "current" one for inject(), helpers and facades (AsyncLocalStorage). */
+    run<R>(fn: () => R): R;
+}
+declare const Container$1: Token<Container$1>;
+
+interface ServiceProvider {
+    /** Bind things into the container. Synchronous. Don't resolve other services here. */
+    register?(): void;
+    /** Runs after every provider is registered. May be async (e.g. importing route files). */
+    boot?(): void | Promise<void>;
+}
+type ServiceProviderClass = new (app: Application$1) => ServiceProvider;
+interface Application$1 extends Container$1 {
+    readonly version: string;
+    basePath(path?: string): string;
+    appPath(path?: string): string;
+    bootstrapPath(path?: string): string;
+    configPath(path?: string): string;
+    databasePath(path?: string): string;
+    publicPath(path?: string): string;
+    resourcePath(path?: string): string;
+    storagePath(path?: string): string;
+    /** With no args returns the environment name. With args returns whether it matches any of them. */
+    environment(): string;
+    environment(...environments: string[]): boolean;
+    isProduction(): boolean;
+    isLocal(): boolean;
+    runningInConsole(): boolean;
+    /** Mark the app as running in the console (the CLI entry point calls this). Defaults to true. */
+    setRunningInConsole(value?: boolean): void;
+    runningUnitTests(): boolean;
+    /** Registers the provider. If the app is already booted, the provider is booted immediately. */
+    register(provider: ServiceProvider | ServiceProviderClass): Promise<ServiceProvider>;
+    getProviders(): ServiceProvider[];
+    boot(): Promise<void>;
+    isBooted(): boolean;
+    booting(callback: (app: Application$1) => void | Promise<void>): void;
+    booted(callback: (app: Application$1) => void | Promise<void>): void;
+    /** Handle one HTTP request in a fresh request scope via the bound HttpKernel. */
+    handle(request: Request): Promise<Response>;
+    /** Register a callback that terminate() runs, in registration order. */
+    terminating(callback: () => void | Promise<void>): void;
+    terminate(): Promise<void>;
+}
+declare const Application$1: Token<Application$1>;
+/** The object passed to Application.configure().withExceptions(e => …), like Laravel's Exceptions class. */
+interface ExceptionsConfigurator {
+    /** Custom reporting. Return false to stop the default logging. */
+    report(callback: (error: unknown) => void | boolean | Promise<void | boolean>): this;
+    /** Custom rendering. Return undefined to fall through to the default rendering. */
+    render(callback: (error: unknown, request: unknown) => Response | undefined | Promise<Response | undefined>): this;
+    /** Never report errors of these classes. */
+    dontReport(...classes: Array<abstract new (...args: never[]) => Error>): this;
+}
+
+/** The session of the current request (scoped). Loaded and saved by the StartSession middleware. */
+interface Session {
+    getId(): string;
+    start(): Promise<void>;
+    save(): Promise<void>;
+    all(): Record<string, unknown>;
+    has(key: string): boolean;
+    get<T = unknown>(key: string, defaultValue?: T): T;
+    put(key: string | Record<string, unknown>, value?: unknown): void;
+    push(key: string, value: unknown): void;
+    pull<T = unknown>(key: string, defaultValue?: T): T;
+    forget(...keys: string[]): void;
+    flush(): void;
+    flash(key: string, value: unknown): void;
+    now(key: string, value: unknown): void;
+    reflash(): void;
+    keep(...keys: string[]): void;
+    getOldInput<T = unknown>(key?: string, defaultValue?: T): T;
+    flashInput(input: Record<string, unknown>): void;
+    token(): string;
+    regenerateToken(): void;
+    regenerate(destroy?: boolean): Promise<void>;
+    invalidate(): Promise<void>;
+    previousUrl(): string | undefined;
+    setPreviousUrl(url: string): void;
+}
+declare const Session: Token<Session>;
+interface UploadedFile {
+    readonly clientName: string;
+    readonly mimeType: string;
+    readonly size: number;
+    extension(): string;
+    arrayBuffer(): Promise<ArrayBuffer>;
+    /** Stores on a Filesystem disk. Returns the stored path. */
+    store(directory: string, disk?: string): Promise<string>;
+    storeAs(directory: string, name: string, disk?: string): Promise<string>;
+}
+/**
+ * Oriel's request wrapper (one per request, scoped).
+ * The Http kernel awaits `load()` before any middleware runs, so every input accessor below is synchronous.
+ */
+interface HttpRequest {
+    readonly raw: Request;
+    load(): Promise<this>;
+    method(): string;
+    isMethod(method: string): boolean;
+    url(): string;
+    fullUrl(): string;
+    path(): string;
+    is(...patterns: string[]): boolean;
+    routeIs(...names: string[]): boolean;
+    header(name: string): string | undefined;
+    header(name: string, defaultValue: string): string;
+    bearerToken(): string | undefined;
+    ip(): string | undefined;
+    expectsJson(): boolean;
+    ajax(): boolean;
+    query<T = unknown>(key?: string, defaultValue?: T): T;
+    input<T = unknown>(key?: string, defaultValue?: T): T;
+    all(): Record<string, unknown>;
+    only(...keys: string[]): Record<string, unknown>;
+    except(...keys: string[]): Record<string, unknown>;
+    has(...keys: string[]): boolean;
+    filled(key: string): boolean;
+    boolean(key: string, defaultValue?: boolean): boolean;
+    integer(key: string, defaultValue?: number): number;
+    merge(values: Record<string, unknown>): this;
+    file(key: string): UploadedFile | undefined;
+    cookie(name: string): string | undefined;
+    /** Route parameter (after model binding), or every parameter when called with no key. */
+    route<T = unknown>(key?: string): T;
+    session(): Session;
+    /** The user resolved earlier by auth middleware. Undefined for guests. Use `await Auth.user()` to resolve lazily. */
+    user<T = unknown>(guard?: string): T | undefined;
+    setUserResolver(resolver: (guard?: string) => unknown): void;
+}
+declare const HttpRequest: Token<HttpRequest>;
+type Next = (request: HttpRequest) => Promise<Response>;
+interface Middleware {
+    handle(request: HttpRequest, next: Next, ...parameters: string[]): Promise<Response>;
+    terminate?(request: HttpRequest, response: Response): Promise<void>;
+}
+type MiddlewareClass = new (...args: any[]) => Middleware;
+/** The object passed to Application.configure().withMiddleware(m => …), like Laravel's Middleware class. */
+interface MiddlewareConfigurator {
+    append(...middleware: MiddlewareClass[]): this;
+    prepend(...middleware: MiddlewareClass[]): this;
+    web(options: {
+        append?: MiddlewareClass[];
+        prepend?: MiddlewareClass[];
+        remove?: MiddlewareClass[];
+    }): this;
+    api(options: {
+        append?: MiddlewareClass[];
+        prepend?: MiddlewareClass[];
+        remove?: MiddlewareClass[];
+    }): this;
+    alias(aliases: Record<string, MiddlewareClass>): this;
+    group(name: string, middleware: Array<MiddlewareClass | string>): this;
+    validateCsrfTokens(options: {
+        except: string[];
+    }): this;
+    redirectGuestsTo(url: string | ((request: HttpRequest) => string)): this;
+}
+interface HttpKernel {
+    handle(request: Request): Promise<Response>;
+    terminate?(request: Request, response: Response): Promise<void>;
+}
+declare const HttpKernel: Token<HttpKernel>;
+
+type Key = unknown;
+type Lifetime = 'transient' | 'singleton' | 'scoped';
+interface Binding {
+    lifetime: Lifetime;
+    factory: Factory$2<unknown>;
+}
+type Extender = (instance: unknown, c: Container$4) => unknown;
+type Callback = (instance: unknown, c: Container$4) => void;
+interface SharedState {
+    bindings: Map<Key, Binding>;
+    extenders: Map<Key, Extender[]>;
+    resolving: Map<Key, Callback[]>;
+    resolved: Set<Key>;
+}
+declare class Container implements Container$4 {
+    #private;
+    static getInstance(): Container | undefined;
+    static setInstance(container: Container | undefined): void;
+    protected readonly shared: SharedState;
+    protected readonly root: Container;
+    protected readonly parent: Container | undefined;
+    protected readonly local: Map<unknown, unknown>;
+    constructor(parent?: Container);
+    bind<T>(abstract: Abstract$2<T>, concrete?: Concrete$2<T>): void;
+    singleton<T>(abstract: Abstract$2<T>, concrete?: Concrete$2<T>): void;
+    scoped<T>(abstract: Abstract$2<T>, concrete?: Concrete$2<T>): void;
+    instance<T>(abstract: Abstract$2<T>, instance: T): T;
+    make<T>(abstract: Abstract$2<T>): T;
+    bound(abstract: Abstract$2<unknown>): boolean;
+    resolved(abstract: Abstract$2<unknown>): boolean;
+    extend<T>(abstract: Abstract$2<T>, extender: (instance: T, container: Container$4) => T): void;
+    resolving<T>(abstract: Abstract$2<T>, callback: (instance: T, container: Container$4) => void): void;
+    forgetInstance(abstract: Abstract$2<unknown>): void;
+    /** Scopes are always plain Containers (never subclasses such as Application). */
+    createScope(): Container;
+    run<R>(fn: () => R): R;
+    protected build(abstract: Abstract$2<unknown>, key: Key, binding: Binding): unknown;
+}
+
+interface RoutingOptions {
+    web?: string;
+    api?: string;
+    console?: string;
+    /** A URI such as '/up', not a file. */
+    health?: string;
+    apiPrefix?: string;
+}
+type Lifecycle = (app: Application$1) => void | Promise<void>;
+declare class ApplicationBuilder {
+    private readonly app;
+    private readonly providers;
+    private readonly middleware;
+    private readonly exceptions;
+    private routing;
+    constructor(app: Application);
+    withProviders(providers?: Array<ServiceProvider | ServiceProviderClass>): this;
+    withRouting(options: RoutingOptions): this;
+    withMiddleware(callback: (middleware: MiddlewareConfigurator) => void): this;
+    withExceptions(callback: (exceptions: ExceptionsConfigurator) => void): this;
+    booting(callback: Lifecycle): this;
+    booted(callback: Lifecycle): this;
+    create(): Promise<Application>;
+}
+
+type LifecycleCallback = (app: Application$1) => void | Promise<void>;
+declare class Application extends Container implements Application$1 {
+    private readonly base;
+    readonly version = "0.0.0";
+    private readonly providers;
+    private readonly bootingCallbacks;
+    private readonly bootedCallbacks;
+    private readonly terminatingCallbacks;
+    private bootPromise;
+    private hasBooted;
+    private inConsole;
+    constructor(base: string);
+    /** Entry point used by bootstrap/app.ts. */
+    static configure(options: {
+        basePath: string;
+    }): ApplicationBuilder;
+    basePath(path?: string): string;
+    appPath(path?: string): string;
+    bootstrapPath(path?: string): string;
+    configPath(path?: string): string;
+    databasePath(path?: string): string;
+    publicPath(path?: string): string;
+    resourcePath(path?: string): string;
+    storagePath(path?: string): string;
+    environment(): string;
+    environment(...environments: string[]): boolean;
+    isProduction(): boolean;
+    isLocal(): boolean;
+    runningUnitTests(): boolean;
+    runningInConsole(): boolean;
+    setRunningInConsole(value?: boolean): void;
+    register(provider: ServiceProvider | ServiceProviderClass): Promise<ServiceProvider>;
+    getProviders(): ServiceProvider[];
+    boot(): Promise<void>;
+    isBooted(): boolean;
+    booting(callback: LifecycleCallback): void;
+    /** If already booted, the callback runs immediately (a rejection surfaces as an unhandled rejection). */
+    booted(callback: LifecycleCallback): void;
+    terminating(callback: () => void | Promise<void>): void;
+    handle(request: Request): Promise<Response>;
+    terminate(): Promise<void>;
+    private runBoot;
+    private bootProvider;
+}
+
+type Handler = (request: Request) => unknown;
+/** Wave 0 stand-in for the Http kernel: exact "METHOD /path" matching only. Replaced by Wave 1's router. */
+declare class ClosureKernel implements HttpKernel {
+    private readonly routes;
+    on(method: string, path: string, handler: Handler): this;
+    handle(request: Request): Promise<Response>;
+}
+
+declare class ProviderBootError extends Error {
+    readonly provider: string;
+    readonly name = "ProviderBootError";
+    constructor(provider: string, cause: unknown);
+}
+declare class ProviderRegisterError extends Error {
+    readonly provider: string;
+    readonly name = "ProviderRegisterError";
+    constructor(provider: string, cause: unknown);
+}
+
+export { Application, ApplicationBuilder, Arr, BindingResolutionError, CircularDependencyError, ClassRegistry, ClosureKernel, Collection$1 as Collection, Container$3 as Container, ContainerNotAvailableError, type Facade, type FacadeStatics, LazyCollection, ProviderBootError, ProviderRegisterError, Repository, type RoutingOptions, ServiceProvider$1 as ServiceProvider, Str, app, collect, config, currentContainer, env, facade, inject, now, retry, tap, value };