@orieljs/framework 0.1.0-alpha.6 → 0.1.0-alpha.7

package/dist/contracts.js

@@ -44,7 +44,7 @@ import {
   ValidationFactory,
   ViewFactory,
   token
-} from "./chunk-I63ZFMX6.js";
+} from "./chunk-GVNLZZTN.js";
 export {
   Application,
   AuthFactory,

package/dist/index.d-WQpfdIbG.d.ts

@@ -0,0 +1,630 @@
+import { Enumerable, ServiceProvider as ServiceProvider$1, Application, ClassRegistry as ClassRegistry$1, Class, Abstract, ConfigRepository } from './contracts.js';
+
+type Operator = '=' | '==' | '===' | '!=' | '!==' | '<>' | '<' | '<=' | '>' | '>=';
+
+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<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<T>>;
+}
+
+type Getter<T, V = unknown> = (keyof T & string) | ((item: T) => V);
+type Predicate<T> = (item: T, index: number) => unknown;
+/** A class whose instances whereInstanceOf() keeps. */
+type ClassOf<I = unknown> = abstract new (...args: never) => I;
+/** One step of sortBy([...]): a key, [key, direction], or a comparator. */
+type SortStep<T> = (keyof T & string) | readonly [Getter<T>, ('asc' | 'desc')?] | ((a: T, b: T) => number);
+/** One level of flatten(1): arrays and collections give their items, anything else stays. */
+type Flat1<T> = T extends Collection<infer U> ? U : T extends readonly (infer U)[] ? U : T;
+/** flatten(): the leaves of nested arrays and collections. */
+type Flat<T> = T extends Collection<infer U> ? Flat<U> : T extends readonly (infer U)[] ? Flat<U> : T;
+/**
+ * The item type of a collection type. Methods whose result type depends on the item type through a conditional type
+ * (collapse(), flatten()) take it from their `this` type instead of T, so Collection<T> stays covariant in T.
+ */
+type ItemOf<C> = C extends Collection<infer U> ? U : never;
+/**
+ * The arguments mapSpread()/eachSpread() pass: a tuple's items, then the index; an array's or a collection's items
+ * (the index is still passed last, but isn't in the type, which can't place it after a list of unknown length).
+ */
+type SpreadArgs<I> = I extends Collection<infer V> ? V[] : I extends readonly unknown[] ? (number extends I['length'] ? I : [...I, number]) : never;
+/** What when()/unless() return: the callback's result, or the collection when it returns nothing. */
+type Outcome<U> = Exclude<U, void | undefined | null>;
+/** The type names ensure() accepts besides classes: typeof's, plus 'null' and 'array'. */
+type TypeName = 'string' | 'number' | 'bigint' | 'boolean' | 'symbol' | 'undefined' | 'function' | 'object' | 'null' | 'array';
+type TypeOfName<N> = N extends 'string' ? string : N extends 'number' ? number : N extends 'bigint' ? bigint : N extends 'boolean' ? boolean : N extends 'symbol' ? symbol : N extends 'undefined' ? undefined : N extends 'function' ? (...args: never[]) => unknown : N extends 'object' ? object : N extends 'null' ? null : N extends 'array' ? unknown[] : never;
+type Ensured<E> = E extends TypeName ? TypeOfName<E> : E extends ClassOf<infer I> ? I : never;
+/** The item types of crossJoin()'s lists. */
+type ItemsOf<L extends readonly Iterable<unknown>[]> = {
+    [K in keyof L]: L[K] extends Iterable<infer U> ? U : never;
+};
+/**
+ * Laravel's Collection over a list. Methods that return the same items return the receiver's class (a subclass keeps
+ * its class); methods that change the items return a base Collection. `out T`: a Collection<Dog> is a
+ * Collection<Animal>, so no member may use T contravariantly (callbacks of T are checked as method parameters).
+ */
+declare class Collection<out 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>;
+    /** The numbers from `from` to `to`, inclusive, counting up or down by `step` (PHP's range()). */
+    static range(from: number, to: number, step?: number): Collection<number>;
+    /** A collection of the value: an array's or collection's items, nothing for null or undefined, else [value]. */
+    static wrap<T>(value: Collection<T>): Collection<T>;
+    static wrap<T>(value: readonly T[]): Collection<T>;
+    static wrap<T>(value: T | null | undefined): Collection<NonNullable<T>>;
+    /** A collection's items as an array; anything else as it is. */
+    static unwrap<T>(value: Collection<T>): T[];
+    static unwrap<V>(value: V): V;
+    static empty<T = never>(): Collection<T>;
+    /** The decoded JSON: an array's items, nothing for null, else the one value. */
+    static fromJson<T = unknown>(json: string): Collection<T>;
+    /** A new collection of the receiver's class (a subclass keeps its class through filter(), sortBy(), …). */
+    protected newInstance(items?: Iterable<T>): this;
+    [Symbol.iterator](): Iterator<T>;
+    all(): T[];
+    count(): number;
+    isEmpty(): boolean;
+    isNotEmpty(): boolean;
+    toArray(): unknown[];
+    toJSON(): T[];
+    toJson(): string;
+    /** The item at an index, or the default (a function default is called). */
+    get(index: number): T | undefined;
+    get<D>(index: number, defaultValue: D | (() => D)): T | D;
+    /** Whether every given index exists. */
+    has(...indexes: Array<number | readonly number[]>): boolean;
+    /** Whether any of the given indexes exists. */
+    hasAny(...indexes: Array<number | readonly number[]>): boolean;
+    /** The index of the first item equal to the value (loosely, unless strict) or passing the callback; false when none. */
+    search(callback: Predicate<T>): number | false;
+    search(value: T, strict?: boolean): number | false;
+    /** The item before the first match of search(). */
+    before(callback: Predicate<T>): T | undefined;
+    before(value: T, strict?: boolean): T | undefined;
+    /** The item after the first match of search(). */
+    after(callback: Predicate<T>): T | undefined;
+    after(value: T, strict?: boolean): T | undefined;
+    /** The key's value on the first item where it is truthy, or the default. */
+    value<K extends keyof T & string>(key: K): NonNullable<T[K]> | undefined;
+    value<K extends keyof T & string, D>(key: K, defaultValue: D | (() => D)): NonNullable<T[K]> | D;
+    /** Whether every item passes the callback, has a truthy key, or meets a where condition. Empty is true. */
+    every(callback: Predicate<T>): boolean;
+    every(key: keyof T & string): boolean;
+    every(key: Getter<T>, value: unknown): boolean;
+    every(key: Getter<T>, operator: Operator, value: unknown): boolean;
+    /**
+     * Whether an item is the value (strictly), passes the callback, has the key's value (strictly), or meets a where
+     * condition (key, operator, value).
+     */
+    contains(key: keyof T & string, value: unknown): boolean;
+    contains(key: Getter<T>, operator: Operator, value: unknown): boolean;
+    contains(callback: (item: T) => boolean): boolean;
+    contains(value: unknown): boolean;
+    /** contains() under Laravel's other name. */
+    some(key: keyof T & string, value: unknown): boolean;
+    some(key: Getter<T>, operator: Operator, value: unknown): boolean;
+    some(callback: (item: T) => boolean): boolean;
+    some(value: unknown): boolean;
+    /** contains() with strict comparison (contains() already compares values strictly). */
+    containsStrict(key: keyof T & string, value: unknown): boolean;
+    containsStrict(callback: (item: T) => boolean): boolean;
+    containsStrict(value: unknown): boolean;
+    doesntContain(key: keyof T & string, value: unknown): boolean;
+    doesntContain(key: Getter<T>, operator: Operator, value: unknown): boolean;
+    doesntContain(callback: (item: T) => boolean): boolean;
+    doesntContain(value: unknown): boolean;
+    doesntContainStrict(key: keyof T & string, value: unknown): boolean;
+    doesntContainStrict(callback: (item: T) => boolean): boolean;
+    doesntContainStrict(value: unknown): boolean;
+    /** Whether there is exactly one item (that passes the callback). */
+    containsOneItem(callback?: Predicate<T>): boolean;
+    /** The only item (that matches), or ItemNotFoundError / MultipleItemsFoundError. */
+    sole(callback?: Predicate<T>): T;
+    sole(key: Getter<T>, value: unknown): T;
+    sole(key: Getter<T>, operator: Operator, value: unknown): T;
+    /** The first item (that matches), or ItemNotFoundError. */
+    firstOrFail(callback?: Predicate<T>): T;
+    firstOrFail(key: Getter<T>, value: unknown): T;
+    firstOrFail(key: Getter<T>, operator: Operator, value: unknown): T;
+    /** The items a callback or a where condition (sole(), firstOrFail()) selects; every item without arguments. */
+    private matching;
+    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): this;
+    reject(callback: (item: T, index: number) => unknown): this;
+    /** 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('active') keeps truthy values; where('role', 'admin') compares with `=` (loosely); or key, operator, value. */
+    where(key: Getter<T>): this;
+    where(key: Getter<T>, value: unknown): this;
+    where(key: Getter<T>, operator: Operator, value: unknown): this;
+    /** where() with strict comparison (===). */
+    whereStrict(key: Getter<T>, value: unknown): this;
+    firstWhere(key: Getter<T>): T | undefined;
+    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[]): this;
+    /** whereIn() under Laravel's strict name (whereIn() already compares strictly). */
+    whereInStrict(key: Getter<T>, values: readonly unknown[]): this;
+    whereNotIn(key: Getter<T>, values: readonly unknown[]): this;
+    whereNotInStrict(key: Getter<T>, values: readonly unknown[]): this;
+    /** Items whose key (or the item itself) is null or undefined (a missing key counts as null). */
+    whereNull(key?: Getter<T>): this;
+    whereNotNull(key?: Getter<T>): this;
+    /** Items whose key is within the first and last values, inclusive. */
+    whereBetween(key: Getter<T>, values: readonly unknown[]): this;
+    whereNotBetween(key: Getter<T>, values: readonly unknown[]): this;
+    /** Items that are instances of the class (or of any of the classes). */
+    whereInstanceOf<C extends ClassOf>(type: C | readonly C[]): Collection<InstanceType<C>>;
+    pluck<K extends keyof T & string>(key: K): Collection<T[K]>;
+    keyBy(key: Getter<T>): Record<string, T>;
+    groupBy(key: Getter<T>): Record<string, this>;
+    mapWithKeys<V>(callback: (item: T, index: number) => readonly [string, V]): Record<string, V>;
+    /** The repeated values (loosely compared), or of a key or a callback: ['a', 'b', 'a'] → ['a']. */
+    duplicates(): Collection<T>;
+    duplicates<K extends keyof T & string>(key: K): Collection<T[K]>;
+    duplicates<V>(callback: (item: T) => V): Collection<V>;
+    /** duplicates() with strict comparison. */
+    duplicatesStrict(): Collection<T>;
+    duplicatesStrict<K extends keyof T & string>(key: K): Collection<T[K]>;
+    duplicatesStrict<V>(callback: (item: T) => V): Collection<V>;
+    /** Laravel's duplicates(): each value after the first of its kind. */
+    private repeated;
+    /** The items that aren't in the given items (strict comparison). */
+    diff(items: Iterable<T>): this;
+    /** diff() with a comparator that returns 0 for equal items. */
+    diffUsing(items: Iterable<T>, callback: (a: T, b: T) => number): this;
+    /** The items that are also in the given items (strict comparison). */
+    intersect(items: Iterable<T>): this;
+    intersectUsing(items: Iterable<T>, callback: (a: T, b: T) => number): this;
+    /** Sorted with the default ascending order (numbers, dates, then strings), or by a comparator. */
+    sort(callback?: (a: T, b: T) => number): this;
+    sortDesc(): this;
+    /**
+     * Stable sort by a key or a callback value, nulls last both ways; or by several steps:
+     * sortBy([['name', 'asc'], ['age', 'desc']]), sortBy(['name', (a, b) => b.age - a.age]).
+     */
+    sortBy(key: Getter<T>, direction?: 'asc' | 'desc'): this;
+    sortBy(steps: ReadonlyArray<SortStep<T>>): this;
+    sortByDesc(key: Getter<T>): this;
+    sum(key?: Getter<T>): number;
+    avg(key?: Getter<T>): number | undefined;
+    min(key?: Getter<T>): number | undefined;
+    max(key?: Getter<T>): number | undefined;
+    /** avg() under Laravel's other name. */
+    average(key?: Getter<T>): number | undefined;
+    /** The middle number (the mean of the two middle ones for an even count), ignoring null and non-numbers. */
+    median(key?: Getter<T>): number | undefined;
+    /** The most frequent values (strict comparison), in the order they first appear; undefined when empty. */
+    mode(): T[] | undefined;
+    mode<K extends keyof T & string>(key: K): Array<T[K]> | undefined;
+    /** The share of items that pass the callback, as a percentage rounded to `precision` places; undefined when empty. */
+    percentage(callback: Predicate<T>, precision?: number): number | undefined;
+    /** How many items have each value, key value or callback result: [1, 2, 2].countBy() → { 1: 1, 2: 2 }. */
+    countBy(key?: Getter<T>): Record<string, number>;
+    /** Groups the callback's [key, value] pairs: values under the same key are collected in arrays. */
+    mapToDictionary<V>(callback: (item: T, index: number) => readonly [PropertyKey, V]): Record<string, V[]>;
+    /** mapToDictionary() with each group as a collection. */
+    mapToGroups<V>(callback: (item: T, index: number) => readonly [PropertyKey, V]): Record<string, Collection<V>>;
+    /** A new instance of the class for each item: new cls(item, index). */
+    mapInto<C>(cls: new (item: T, index: number) => C): Collection<C>;
+    /** Maps nested arrays (or collections) with their items as the arguments, then the index. */
+    mapSpread<U, C extends Collection<unknown>>(this: C, callback: (...args: SpreadArgs<ItemOf<C>>) => U): Collection<U>;
+    /** each() with the nested items as the arguments, then the index. Return false to stop. */
+    eachSpread<C extends Collection<unknown>>(this: C, callback: (...args: SpreadArgs<ItemOf<C>>) => unknown): C;
+    /** reduce() with several carried values: the reducer gets them, then the item and index, and returns them as an array. */
+    reduceSpread<A extends unknown[]>(callback: (...args: [...A, T, number]) => [...NoInfer<A>], ...initial: A): A;
+    /** The first item of each value (strict comparison), or of each key or callback value. */
+    unique(key?: Getter<T>): this;
+    /** unique() under Laravel's strict name (unique() already compares strictly). */
+    uniqueStrict(key?: Getter<T>): this;
+    chunk(size: number): Collection<this>;
+    /** Negative count takes from the end. */
+    take(count: number): this;
+    skip(count: number): this;
+    /** PHP's array_slice(): a negative offset counts from the end; a negative length leaves that many off the end. */
+    slice(offset: number, length?: number): this;
+    values(): this;
+    /** Mutates, like Laravel. */
+    push(...values: T[]): this;
+    concat(values: Iterable<T>): this;
+    partition(callback: (item: T, index: number) => unknown): [this, this];
+    reverse(): this;
+    shuffle(): this;
+    /** One random item, or `count` of them (a number or a function of the collection) in their original order. */
+    random(): T;
+    random(count: number | ((collection: this) => number)): this;
+    /** Every step-th item, starting at offset. */
+    nth(step: number, offset?: number): this;
+    /** Pads to `size` items with the value; a negative size pads at the start (PHP's array_pad()). */
+    pad<V>(size: number, value: V): Collection<T | V>;
+    /** The items of one page: forPage(2, 15). */
+    forPage(page: number, perPage: number): this;
+    /** `count` groups of nearly equal size, the first ones larger. */
+    split(count: number): Collection<this>;
+    /** `count` groups, every group full except the last. */
+    splitIn(count: number): Collection<this>;
+    /** Overlapping windows of `size` items, `step` apart: [1, 2, 3].sliding(2) → [[1, 2], [2, 3]]. */
+    sliding(size?: number, step?: number): Collection<this>;
+    /** Chunks that grow while the callback (value, index, the current chunk) returns true. */
+    chunkWhile(callback: (value: T, index: number, chunk: this) => unknown): Collection<this>;
+    /** The items before the first one that is the value (strictly) or passes the callback. */
+    takeUntil(callback: Predicate<T>): this;
+    takeUntil(value: T): this;
+    /** The items up to the first one that isn't the value or fails the callback. */
+    takeWhile(callback: Predicate<T>): this;
+    takeWhile(value: T): this;
+    /** The items from the first one that is the value or passes the callback. */
+    skipUntil(callback: Predicate<T>): this;
+    skipUntil(value: T): this;
+    /** The items from the first one that isn't the value or fails the callback. */
+    skipWhile(callback: Predicate<T>): this;
+    skipWhile(value: T): this;
+    /** The items at the given indexes, in collection order. */
+    only(...indexes: Array<number | readonly number[]>): this;
+    /** The items except those at the given indexes. */
+    except(...indexes: Array<number | readonly number[]>): this;
+    /** The indexes: 0, 1, 2, … */
+    keys(): Collection<number>;
+    /** Removes and returns the last item; with a count, a collection of the last `count` items, last first. */
+    pop(): T | undefined;
+    pop(count: number): this;
+    /** Removes and returns the first item; with a count, a collection of the first `count` items. */
+    shift(): T | undefined;
+    shift(count: number): this;
+    /** Adds an item at the start (mutates). */
+    prepend(value: T): this;
+    /** Adds items at the start, in the given order (mutates). */
+    unshift(...values: T[]): this;
+    /** Adds one item at the end (mutates). */
+    add(item: T): this;
+    /** Sets the item at an index (mutates); an index at or past the end appends. */
+    put(index: number, value: T): this;
+    /** Removes and returns the item at an index (mutates), or the default. */
+    pull(index: number): T | undefined;
+    pull<D>(index: number, defaultValue: D | (() => D)): T | D;
+    /** Removes the items at the given indexes (mutates); the later items move up. */
+    forget(...indexes: Array<number | readonly number[]>): this;
+    /**
+     * Removes `length` items from `offset` (mutates), inserting the replacement there, and returns the removed items
+     * (PHP's array_splice(): a negative offset counts from the end; a negative length leaves that many at the end).
+     */
+    splice(offset: number, length?: number, replacement?: Iterable<T>): this;
+    /** Replaces every item with the callback's result (mutates) and returns this collection, typed with the new items. */
+    transform<U>(callback: (item: T, index: number) => U): Collection<U>;
+    /**
+     * A copy with items replaced by index: an array from index 0, or { index: value }; past the end appends, and a
+     * negative or fractional index throws a RangeError, as put() does.
+     */
+    replace(items: Iterable<T> | Readonly<Record<number, T>>): this;
+    /** One level of nested arrays and collections, merged (other items are dropped). */
+    collapse<U>(this: Collection<readonly U[] | Collection<U>>): Collection<U>;
+    /** Nested arrays and collections opened up (all levels, or `depth`); plain objects are kept whole. */
+    flatten<C extends Collection<unknown>>(this: C): Collection<Flat<ItemOf<C>>>;
+    flatten<C extends Collection<unknown>>(this: C, depth: 1): Collection<Flat1<ItemOf<C>>>;
+    flatten(depth: number): Collection<unknown>;
+    /** Every combination of the items with the lists' items: [1, 2] × ['a'] → [[1, 'a'], [2, 'a']]. */
+    crossJoin<L extends readonly Iterable<unknown>[]>(...lists: L): Collection<[T, ...ItemsOf<L>]>;
+    /** Pairs items by index with the lists' items, as collections; the shorter lists give undefined. */
+    zip<U>(...lists: Array<Iterable<U>>): Collection<Collection<T | U | undefined>>;
+    /** The items as keys for the values: ['name', 'age'].combine(['George', 29]) → { name: 'George', age: 29 }. */
+    combine<V>(values: Iterable<V>): Record<string, V>;
+    /** Each item as a key for its index: ['a', 'b'] → { a: 0, b: 1 }. */
+    flip(): Record<string, number>;
+    /** The items followed by the given ones (a list merges by appending). */
+    merge(items: Iterable<T>): this;
+    /** The items repeated `multiplier` times. */
+    multiply(multiplier: number): this;
+    /**
+     * Each item reduced to the given keys it has: select(['name', 'role']). An item has a key when `key in item` or
+     * reading it gives a value, so a model's attributes, which its proxy serves on read, are kept.
+     */
+    select<K extends keyof T & string>(...keys: Array<K | readonly K[]>): Collection<Pick<T, K>>;
+    /** A LazyCollection over a copy of the items: later changes to this collection don't reach it. */
+    lazy(): LazyCollection<T>;
+    /** A base collection with the same items. */
+    collect(): Collection<T>;
+    implode(glue: string): string;
+    implode(key: keyof T & string, glue: string): string;
+    implode(callback: (item: T, index: number) => unknown, glue: string): string;
+    /** implode() with a different glue before the last item: join(', ', ' and ') → 'a, b and c'. */
+    join(glue: string, finalGlue?: string): string;
+    /**
+     * Runs the callback (collection, value) when the value is truthy, else the default; a function value is called with
+     * the collection first. Returns what the callback returns, or the collection when it returns nothing.
+     */
+    when<V, U = this, D = this>(value: V | ((collection: this) => V), callback: (collection: this, value: V) => U, otherwise?: (collection: this, value: V) => D): this | Outcome<U> | Outcome<D>;
+    /** when() with the condition reversed. */
+    unless<V, U = this, D = this>(value: V | ((collection: this) => V), callback: (collection: this, value: V) => U, otherwise?: (collection: this, value: V) => D): this | Outcome<U> | Outcome<D>;
+    whenEmpty<U = this, D = this>(callback: (collection: this) => U, otherwise?: (collection: this) => D): this | Outcome<U> | Outcome<D>;
+    whenNotEmpty<U = this, D = this>(callback: (collection: this) => U, otherwise?: (collection: this) => D): this | Outcome<U> | Outcome<D>;
+    /** whenNotEmpty() under Laravel's other name. */
+    unlessEmpty<U = this, D = this>(callback: (collection: this) => U, otherwise?: (collection: this) => D): this | Outcome<U> | Outcome<D>;
+    /** whenEmpty() under Laravel's other name. */
+    unlessNotEmpty<U = this, D = this>(callback: (collection: this) => U, otherwise?: (collection: this) => D): this | Outcome<U> | Outcome<D>;
+    pipe<U>(callback: (collection: this) => U): U;
+    /** new cls(collection). */
+    pipeInto<C>(cls: new (collection: this) => C): C;
+    /** Passes the collection through the callbacks in order, each getting the previous result. */
+    pipeThrough<A>(callbacks: readonly [(collection: this) => A]): A;
+    pipeThrough<A, B>(callbacks: readonly [(collection: this) => A, (value: A) => B]): B;
+    pipeThrough<A, B, C>(callbacks: readonly [(collection: this) => A, (value: A) => B, (value: B) => C]): C;
+    pipeThrough(callbacks: ReadonlyArray<(value: never) => unknown>): unknown;
+    tap(callback: (collection: this) => void): this;
+    /**
+     * Throws a TypeError unless every item is an instance of one of the classes or of one of the type names (typeof's,
+     * plus 'null' and 'array'), with Laravel's message. Returns the collection, typed with the checked items.
+     */
+    ensure<E extends ClassOf | TypeName>(type: E | readonly E[]): Collection<Ensured<E>>;
+    /** Logs the items (and any extra values) with console.log and returns the collection. */
+    dump(...values: unknown[]): this;
+    /** JSON with four-space indentation (PHP's JSON_PRETTY_PRINT). */
+    toPrettyJson(): string;
+}
+declare function collect<T>(items?: Iterable<T>): Collection<T>;
+
+/** Thrown by sole() and firstOrFail() when no item matches (Laravel's ItemNotFoundException). */
+declare class ItemNotFoundError extends Error {
+    readonly name = "ItemNotFoundError";
+    constructor();
+}
+/** Thrown by sole() when more than one item matches (Laravel's MultipleItemsFoundException). */
+declare class MultipleItemsFoundError extends Error {
+    readonly count: number;
+    readonly name = "MultipleItemsFoundError";
+    constructor(count: number);
+}
+
+/**
+ * Laravel's Stringable: a string with Str's helpers as chainable methods, each returning a new Stringable.
+ * `Str.of(' Café ').trim().slug().toString()` is 'cafe'; `request().string('q')` returns one. It prints as its string.
+ */
+declare class Stringable {
+    #private;
+    constructor(value?: string);
+    after(search: string): Stringable;
+    afterLast(search: string): Stringable;
+    append(...values: string[]): Stringable;
+    ascii(): Stringable;
+    before(search: string): Stringable;
+    beforeLast(search: string): Stringable;
+    between(from: string, to: string): Stringable;
+    camel(): Stringable;
+    contains(needles: string | string[]): boolean;
+    endsWith(needles: string | string[]): boolean;
+    /** The same string as `value` (a string or another Stringable). */
+    exactly(value: string | Stringable): boolean;
+    /** The parts between the delimiters, as a Collection (PHP's explode()). */
+    explode(delimiter: string): Collection<string>;
+    finish(cap: string): Stringable;
+    /** Wildcard match, as Str.is(): `*` matches anything. */
+    is(pattern: string): boolean;
+    isEmpty(): boolean;
+    isNotEmpty(): boolean;
+    kebab(): Stringable;
+    lcfirst(): Stringable;
+    /** The number of characters (code points, as PHP's mb_strlen()). */
+    length(): number;
+    limit(limit?: number, end?: string): Stringable;
+    lower(): Stringable;
+    /** Strips whitespace and invisible characters from the start, or the characters given. */
+    ltrim(characters?: string): Stringable;
+    plural(count?: number): Stringable;
+    prepend(...values: string[]): Stringable;
+    /** Replaces every occurrence of the search string (or of each of several) with `replace`. */
+    replace(search: string | string[], replace: string): Stringable;
+    /** Strips whitespace and invisible characters from the end, or the characters given. */
+    rtrim(characters?: string): Stringable;
+    singular(): Stringable;
+    slug(separator?: string): Stringable;
+    snake(delimiter?: string): Stringable;
+    start(prefix: string): Stringable;
+    startsWith(needles: string | string[]): boolean;
+    studly(): Stringable;
+    title(): Stringable;
+    /** PHP's filter_var(FILTER_VALIDATE_BOOLEAN): '1', 'true', 'on' and 'yes' (any case, trimmed) are true. */
+    toBoolean(): boolean;
+    /** PHP's floatval(): the leading number, else 0. */
+    toFloat(): number;
+    /** PHP's intval(): the leading digits, else 0. */
+    toInteger(): number;
+    toJSON(): string;
+    toString(): string;
+    /** Strips whitespace and invisible characters from both ends (Laravel's Str::trim()), or the characters given. */
+    trim(characters?: string): Stringable;
+    ucfirst(): Stringable;
+    upper(): Stringable;
+    value(): string;
+}
+
+declare const Str: {
+    /** Laravel's Str::of(): the value as a Stringable, for chaining: Str.of(title).trim().slug(). */
+    of: (value?: unknown) => Stringable;
+    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;
+    /** Laravel's Str::ascii(): the value in plain ASCII ('Café' → 'Cafe', 'Ελληνικά' → 'Ellinika'), as for English. */
+    ascii: (v: string) => string;
+    /**
+     * Laravel's Str::slug(): transliterated to ASCII first (unless `language` is null), '@' read as 'at', then lower-cased
+     * letters and digits joined by the separator: 'Café crème' → 'cafe-creme'. What has no ASCII form is dropped.
+     */
+    slug: (title: string, separator?: string, language?: "en" | null, dictionary?: Readonly<Record<string, string>>) => string;
+    plural: (v: string, count?: number) => string;
+    singular: (v: string) => string;
+    random: (length?: number) => string;
+    uuid: () => `${string}-${string}-${string}-${string}-${string}`;
+    /**
+     * A version 7 UUID (RFC 9562): the time in milliseconds first, so ids from later milliseconds sort after earlier ones
+     * (within one millisecond the order is random). Throws a TypeError for a time before 1970, after 10889 or invalid.
+     */
+    uuid7: (time?: Date) => string;
+    /**
+     * A ULID: 26 upper-case Crockford characters, ten for the time in milliseconds and sixteen random, so ids from later
+     * milliseconds sort after earlier ones. Throws a TypeError for a time before 1970, after 10889 or invalid.
+     */
+    ulid: (time?: Date) => string;
+    /** Laravel's Str::isUuid(): five groups of hex digits, any version. */
+    isUuid: (value: unknown) => value is string;
+    /** Laravel's Str::isUlid(): 26 Crockford characters in either case, the first at most 7. */
+    isUlid: (value: unknown) => value is 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 implements ServiceProvider$1 {
+    protected readonly app: Application;
+    constructor(app: Application);
+    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<T>, extras?: X): Facade<T, X>;
+
+declare class ClassRegistry implements ClassRegistry$1 {
+    private readonly byName;
+    private readonly byClass;
+    register(cls: Class<unknown>, name?: string): string;
+    nameOf(cls: Class<unknown>): string | undefined;
+    resolve<T = unknown>(name: string): Class<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;
+declare function app<T>(abstract: Abstract<T>): T;
+declare function config(): ConfigRepository;
+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>;
+
+/**
+ * Laravel's __(): the line for `key` with `:placeholders` filled (`:name`, `:Name` capitalized, `:NAME` upper-cased),
+ * longest placeholder first. A key with no line comes back as is, so a sentence can be its own key:
+ * __('auth.failed'), __('auth.throttle', { seconds: 30 }), __('A reset link will be sent if the account exists.').
+ */
+declare function __(key: string, replace?: Record<string, string | number>): string;
+
+/**
+ * What a file's bytes show it to be, read from its leading bytes the way PHP's finfo reads them for Laravel (the file
+ * validation rules, and the extension a stored upload gets). The client's file name and MIME type are never consulted.
+ */
+interface DetectedType {
+    /** 'image/png', 'text/plain', …; 'application/octet-stream' when no format matches, 'application/x-empty' for no bytes. */
+    readonly mime: string;
+    /** The extensions that name the type, the usual one first. Empty when the bytes match no format. */
+    readonly extensions: readonly string[];
+}
+declare const JPEG: DetectedType;
+declare const PNG: DetectedType;
+declare const GIF: DetectedType;
+declare const WEBP: DetectedType;
+declare const AVIF: DetectedType;
+declare const BMP: DetectedType;
+declare const SVG: DetectedType;
+declare const PDF: DetectedType;
+declare const HTML: DetectedType;
+declare const XML: DetectedType;
+declare const TEXT: DetectedType;
+declare const UNKNOWN: DetectedType;
+declare const EMPTY: DetectedType;
+/** The raster formats the image rule accepts: Laravel 12's jpg, jpeg, png, gif, bmp and webp, plus AVIF. */
+declare const RASTER_IMAGES: ReadonlySet<string>;
+/** Every format recognised by its bytes other than plain text. */
+declare const BINARY_AND_MARKUP_TYPES: readonly DetectedType[];
+/**
+ * How much of a file is read to tell its type: the window checked for binary bytes (libmagic reads its first megabyte
+ * too). Uploads read this much to be named, so naming and validation see the same bytes.
+ */
+declare const SNIFF_BYTES: number;
+/** The type the bytes show. */
+declare function detectFileType(bytes: Uint8Array): DetectedType;
+
+declare const fileType_AVIF: typeof AVIF;
+declare const fileType_BINARY_AND_MARKUP_TYPES: typeof BINARY_AND_MARKUP_TYPES;
+declare const fileType_BMP: typeof BMP;
+type fileType_DetectedType = DetectedType;
+declare const fileType_EMPTY: typeof EMPTY;
+declare const fileType_GIF: typeof GIF;
+declare const fileType_HTML: typeof HTML;
+declare const fileType_JPEG: typeof JPEG;
+declare const fileType_PDF: typeof PDF;
+declare const fileType_PNG: typeof PNG;
+declare const fileType_RASTER_IMAGES: typeof RASTER_IMAGES;
+declare const fileType_SNIFF_BYTES: typeof SNIFF_BYTES;
+declare const fileType_SVG: typeof SVG;
+declare const fileType_TEXT: typeof TEXT;
+declare const fileType_UNKNOWN: typeof UNKNOWN;
+declare const fileType_WEBP: typeof WEBP;
+declare const fileType_XML: typeof XML;
+declare const fileType_detectFileType: typeof detectFileType;
+declare namespace fileType {
+  export { fileType_AVIF as AVIF, fileType_BINARY_AND_MARKUP_TYPES as BINARY_AND_MARKUP_TYPES, fileType_BMP as BMP, type fileType_DetectedType as DetectedType, fileType_EMPTY as EMPTY, fileType_GIF as GIF, fileType_HTML as HTML, fileType_JPEG as JPEG, fileType_PDF as PDF, fileType_PNG as PNG, fileType_RASTER_IMAGES as RASTER_IMAGES, fileType_SNIFF_BYTES as SNIFF_BYTES, fileType_SVG as SVG, fileType_TEXT as TEXT, fileType_UNKNOWN as UNKNOWN, fileType_WEBP as WEBP, fileType_XML as XML, fileType_detectFileType as detectFileType };
+}
+
+export { Arr as A, Collection as C, type Facade as F, ItemNotFoundError as I, LazyCollection as L, MultipleItemsFoundError as M, type Operator as O, ServiceProvider as S, __ as _, Stringable as a, ClassRegistry as b, type FacadeStatics as c, Str as d, app as e, fileType as f, collect as g, config as h, facade as i, now as n, retry as r, tap as t, value as v };