@lakutata/core 1.0.60 → 3.0.0-beta.1

package/dist/types/decorators/di/Inject.d.ts

@@ -0,0 +1,85 @@
+import { PropertyDecorator } from '../../types/PropertyDecorator.js';
+import { BaseObject } from '../../lib/base/BaseObject.js';
+import { InjectionName, InjectionTransformFunction } from '../../lib/base/internal/ObjectInjection.js';
+/**
+ * Inject into the property the object registered in the container under the property's name.
+ * The injection happens when the object is created, before its `@Configurable` properties are set and before its
+ * `init()` runs; it replaces a `@Configurable` declaration of the property in a parent class.
+ * @returns The property decorator.
+ * @throws {DependencyInjectionException} When the object is created, if the registration cannot be resolved (the creation
+ * of the object rejects).
+ * @example
+ * ```typescript
+ * import {Application, Component} from 'lakutata'
+ * import {Inject} from 'lakutata/decorator/di'
+ *
+ * class Mailer extends Component {
+ *     public async send(to: string, text: string): Promise<void> {
+ *         console.log(to, text)
+ *     }
+ * }
+ *
+ * class Signup extends Component {
+ *     //The component registered as "mailer"
+ *     @Inject()
+ *     protected readonly mailer!: Mailer
+ *
+ *     //The object registered for the class (a class marked with @Autoload is registered on first use)
+ *     @Inject(Application)
+ *     protected readonly app!: Application
+ *
+ *     //The component registered as "mailer", transformed: its send function bound to it
+ *     @Inject('mailer', (mailer: Mailer) => mailer.send.bind(mailer))
+ *     protected readonly send!: (to: string, text: string) => Promise<void>
+ *
+ *     public async register(email: string): Promise<void> {
+ *         await this.mailer.send(email, `Welcome to ${this.app.appName}`)
+ *     }
+ * }
+ *
+ * Application.run(() => ({
+ *     id: 'signup.app',
+ *     name: 'Signup',
+ *     components: {
+ *         mailer: {class: Mailer},
+ *         signup: {class: Signup}
+ *     }
+ * }))
+ * ```
+ */
+export declare function Inject<ClassPrototype extends BaseObject>(): PropertyDecorator<ClassPrototype>;
+/**
+ * Inject into the property the object registered in the container under a name, or for a class.
+ * The injection happens when the object is created, before its `@Configurable` properties are set and before its
+ * `init()` runs; it replaces a `@Configurable` declaration of the property in a parent class.
+ * @param name The registration name (a string or a symbol), or a class: the object registered for the class, which is
+ * registered on first use when the class is marked with `@Autoload()`.
+ * @returns The property decorator.
+ * @throws {DependencyInjectionException} When the object is created, if the registration cannot be resolved (the creation
+ * of the object rejects).
+ */
+export declare function Inject<ClassPrototype extends BaseObject>(name: InjectionName): PropertyDecorator<ClassPrototype>;
+/**
+ * Inject into the property a value derived from the object registered in the container under the property's name.
+ * The injection happens when the object is created, before its `@Configurable` properties are set and before its
+ * `init()` runs; it replaces a `@Configurable` declaration of the property in a parent class.
+ * @param transform A function (not a class) receiving the registered object and returning the value set to the
+ * property; it may be async, the property then receives the value it resolves to.
+ * @returns The property decorator.
+ * @throws {DependencyInjectionException} When the object is created, if the registration cannot be resolved (the creation
+ * of the object rejects); an error of `transform` rejects the creation as it is.
+ */
+export declare function Inject<ClassPrototype extends BaseObject>(transform: InjectionTransformFunction): PropertyDecorator<ClassPrototype>;
+/**
+ * Inject into the property a value derived from the object registered in the container under a name, or for a class.
+ * The injection happens when the object is created, before its `@Configurable` properties are set and before its
+ * `init()` runs; it replaces a `@Configurable` declaration of the property in a parent class.
+ * @param name The registration name (a string or a symbol), or a class: the object registered for the class, which is
+ * registered on first use when the class is marked with `@Autoload()`.
+ * @param transform A function receiving the registered object and returning the value set to the property; it may be
+ * async, the property then receives the value it resolves to.
+ * @returns The property decorator.
+ * @throws {DependencyInjectionException} When the object is created, if the registration cannot be resolved (the creation
+ * of the object rejects); an error of `transform` rejects the creation as it is.
+ */
+export declare function Inject<ClassPrototype extends BaseObject>(name: InjectionName, transform: InjectionTransformFunction): PropertyDecorator<ClassPrototype>;

package/dist/types/decorators/di/Lifetime.d.ts

@@ -0,0 +1,94 @@
+import { BaseObject } from '../../lib/base/BaseObject.js';
+import { ClassDecorator } from '../../types/ClassDecorator.js';
+import { LifetimeType } from '../../lib/ioc/Lifetime.js';
+/**
+ * Set how the container shares the instances of a class: `SINGLETON` (one instance, created once by the container
+ * registering the class and shared by all its users), `SCOPED` (one instance per scope, a request of an entrypoint), or
+ * `TRANSIENT` (a new instance on each request, never cached). Subclasses inherit the lifetime. `BaseObject` is
+ * transient, `Provider` scoped (a provider may be a singleton, scoped or transient), `Component` and `Module` are
+ * locked singletons. Prefer the shorthands `@Singleton()`,
+ * `@Scoped()` and `@Transient()`.
+ * @param lifetime The lifetime: `'SINGLETON'`, `'SCOPED'` or `'TRANSIENT'`.
+ * @param lock Whether the subclasses are forbidden to change the lifetime (they may still declare the same one).
+ * Default `false`.
+ * @returns The class decorator.
+ * @throws {LifetimeLockedException} When the class is defined, if a parent class locked another lifetime.
+ * @example
+ * ```typescript
+ * import {BaseObject} from 'lakutata'
+ * import {Lifetime} from 'lakutata/decorator/di'
+ *
+ * //A new counter for each object requesting it
+ * @Lifetime('TRANSIENT')
+ * export class Counter extends BaseObject {
+ *     public value: number = 0
+ * }
+ * ```
+ */
+export declare function Lifetime<ClassConstructor extends typeof BaseObject>(lifetime: LifetimeType, lock?: boolean): ClassDecorator<ClassConstructor>;
+/**
+ * Make the class a singleton: the container registering it creates one instance, on first request, and shares it with
+ * all its users (the scopes included) until the container is destroyed. Shorthand of `@Lifetime('SINGLETON', lock)`.
+ * @param lock Whether the subclasses are forbidden to change the lifetime (they may still declare the same one).
+ * Default `false`.
+ * @returns The class decorator.
+ * @throws {LifetimeLockedException} When the class is defined, if a parent class locked another lifetime.
+ * @example
+ * ```typescript
+ * import {BaseObject} from 'lakutata'
+ * import {Singleton} from 'lakutata/decorator/di'
+ *
+ * //One cache shared by the whole application
+ * @Singleton()
+ * export class Cache extends BaseObject {
+ *     public readonly entries: Map<string, unknown> = new Map()
+ * }
+ * ```
+ */
+export declare function Singleton<ClassConstructor extends typeof BaseObject>(lock?: boolean): ClassDecorator<ClassConstructor>;
+/**
+ * Make the class transient: the container creates a new instance on each request (each `getObject()` and each
+ * injection), never cached. Shorthand of `@Lifetime('TRANSIENT', lock)`; the default of `BaseObject`.
+ * @param lock Whether the subclasses are forbidden to change the lifetime (they may still declare the same one).
+ * Default `false`.
+ * @returns The class decorator.
+ * @throws {LifetimeLockedException} When the class is defined, if a parent class locked another lifetime.
+ * @example
+ * ```typescript
+ * import {Provider} from 'lakutata'
+ * import {Transient} from 'lakutata/decorator/di'
+ *
+ * //Each user of the builder gets its own, with its own state
+ * @Transient()
+ * export class QueryBuilder extends Provider {
+ *     protected readonly clauses: string[] = []
+ *
+ *     public where(clause: string): this {
+ *         this.clauses.push(clause)
+ *         return this
+ *     }
+ * }
+ * ```
+ */
+export declare function Transient<ClassConstructor extends typeof BaseObject>(lock?: boolean): ClassDecorator<ClassConstructor>;
+/**
+ * Make the class scoped: the container creates one instance per scope (an entrypoint creates a scope for each
+ * request), shared by the objects of that scope and destroyed with it; outside a scope, the container registering the
+ * class shares one instance. Shorthand of `@Lifetime('SCOPED', lock)`; the default of `Provider`.
+ * @param lock Whether the subclasses are forbidden to change the lifetime (they may still declare the same one).
+ * Default `false`.
+ * @returns The class decorator.
+ * @throws {LifetimeLockedException} When the class is defined, if a parent class locked another lifetime.
+ * @example
+ * ```typescript
+ * import {Provider} from 'lakutata'
+ * import {Scoped} from 'lakutata/decorator/di'
+ *
+ * //The objects handling the same request share its transaction
+ * @Scoped()
+ * export class RequestTransaction extends Provider {
+ *     public readonly startedAt: number = Date.now()
+ * }
+ * ```
+ */
+export declare function Scoped<ClassConstructor extends typeof BaseObject>(lock?: boolean): ClassDecorator<ClassConstructor>;

package/dist/types/decorators/dto/Accept.d.ts

@@ -0,0 +1,38 @@
+import { DTO } from '../../lib/dto/DTO.js';
+import { MethodDecorator } from '../../types/MethodDecorator.js';
+import { Schema } from '../../lib/validation/types/Schema.js';
+/**
+ * Validate the arguments of each call of the method, in order, against the schemas given; the method then receives the
+ * validated values (defaults applied, the keys without schema removed). A DTO class validates its argument against its
+ * schema: the method receives a plain object, not an instance of the class. The arguments beyond the schemas given are
+ * passed unchecked. An async method is validated asynchronously (its call rejects on failure), another method
+ * synchronously.
+ * @remarks A missing argument is accepted unless its schema is required (`MyDTO.required()`,
+ * `DTO.String().required()`), whether it is omitted or passed as `undefined` (its default then applied).
+ * @param defs The schemas of the arguments, by position: DTO classes or schemas (`DTO.String()`).
+ * @returns The method decorator; the decorated method cannot be reassigned.
+ * @throws {InvalidMethodAcceptException} From a call, when an argument does not match its schema (its cause is the
+ * `InvalidValueException` of the validation).
+ * @example
+ * ```typescript
+ * import {Component, DTO} from 'lakutata'
+ * import {Accept, Expect} from 'lakutata/decorator/dto'
+ *
+ * class TransferDTO extends DTO {
+ *     @Expect(DTO.String().required())
+ *     public to!: string
+ *
+ *     @Expect(DTO.Number().positive().required())
+ *     public amount!: number
+ * }
+ *
+ * class Bank extends Component {
+ *     //The transfer is required, the note optional
+ *     @Accept(TransferDTO.required(), DTO.String().max(140).optional())
+ *     public async transfer(transfer: TransferDTO, note?: string): Promise<void> {
+ *         console.log(`${transfer.amount} to ${transfer.to}`, note)
+ *     }
+ * }
+ * ```
+ */
+export declare function Accept<ClassPrototype, DTOConstructor extends typeof DTO, Method>(...defs: (DTOConstructor | Schema)[]): MethodDecorator<ClassPrototype, Method>;

package/dist/types/decorators/dto/Expect.d.ts

@@ -0,0 +1,38 @@
+import { DTO } from '../../lib/dto/DTO.js';
+import { PropertyDecorator } from '../../types/PropertyDecorator.js';
+import { Schema } from '../../lib/validation/types/Schema.js';
+/**
+ * Declare the schema of a property of a DTO class. The DTO validates the property against it when it is constructed
+ * (the whole object at once: defaults applied, the keys without schema removed unless the class has an
+ * `@IndexSignature`), and each time the property, or a value nested in it, is changed afterwards (the change is undone
+ * when invalid). The schema is also part of the class schema (`MyDTO.Schema()`) used by `@Accept`, `@Return` and the
+ * actions' input validation. Subclasses inherit the property schemas, and may declare a property again to replace its
+ * schema. Ignored on a symbol property or on a class which is not a DTO.
+ * @param schema The schema of the property, built with the static methods of `DTO` (`DTO.String().required()`); a
+ * property is optional unless its schema is marked `required()`.
+ * @returns The property decorator.
+ * @throws {InvalidValueException} From the DTO constructor, or from an assignment to the property, when the value does
+ * not match the schema.
+ * @example
+ * ```typescript
+ * import {DTO} from 'lakutata'
+ * import {Expect} from 'lakutata/decorator/dto'
+ *
+ * class CreateUserDTO extends DTO {
+ *     @Expect(DTO.String().min(2).max(50).required())
+ *     public name!: string
+ *
+ *     @Expect(DTO.String().email().required())
+ *     public email!: string
+ *
+ *     @Expect(DTO.Number().integer().min(0).optional().default(0))
+ *     public credits?: number
+ * }
+ *
+ * //Validated when constructed: credits is 0, an invalid email throws an InvalidValueException
+ * const user: CreateUserDTO = new CreateUserDTO({name: 'Ada', email: 'ada@example.com'})
+ * //Validated when changed: throws an InvalidValueException, the name is unchanged
+ * user.name = 'A'
+ * ```
+ */
+export declare function Expect<ClassPrototype extends DTO>(schema: Schema): PropertyDecorator<ClassPrototype>;

package/dist/types/decorators/dto/IndexSignature.d.ts

@@ -0,0 +1,30 @@
+import { DTO } from '../../lib/dto/DTO.js';
+import { ClassDecorator } from '../../types/ClassDecorator.js';
+import { Schema } from '../../lib/validation/types/Schema.js';
+/**
+ * Accept in a DTO the string keys without an `@Expect` schema, validated against a schema: they are kept instead of
+ * removed, and an invalid one fails the validation (on construction, on assignment, and in the class schema). Without
+ * it, the keys without schema are removed. Subclasses inherit it. `FlexibleDTO` is a DTO accepting any key.
+ * @param schema The schema of the value of each key without its own schema (`DTO.Any()` for any value).
+ * @returns The class decorator.
+ * @throws {InvalidValueException} From the DTO constructor, or from an assignment, when the value of a key without schema
+ * does not match the schema.
+ * @example
+ * ```typescript
+ * import {DTO} from 'lakutata'
+ * import {Expect, IndexSignature} from 'lakutata/decorator/dto'
+ *
+ * //A device and its numeric readings, named freely
+ * @IndexSignature(DTO.Number())
+ * class ReadingsDTO extends DTO {
+ *     [sensor: string]: any
+ *
+ *     @Expect(DTO.String().required())
+ *     public device!: string
+ * }
+ *
+ * const readings: ReadingsDTO = new ReadingsDTO({device: 'boiler', temperature: 61.5, pressure: 1.8})
+ * console.log(readings.temperature)
+ * ```
+ */
+export declare function IndexSignature<ClassConstructor extends typeof DTO>(schema: Schema): ClassDecorator<ClassConstructor>;

package/dist/types/decorators/dto/Return.d.ts

@@ -0,0 +1,39 @@
+import { DTO } from '../../lib/dto/DTO.js';
+import { MethodDecorator } from '../../types/MethodDecorator.js';
+import { Schema } from '../../lib/validation/types/Schema.js';
+/**
+ * Validate the result of each call of the method (awaited for an async method) against a schema; the caller then
+ * receives the validated value (defaults applied, the keys without schema removed). A DTO class validates the result
+ * against its schema: the caller receives a plain object. The schema is also published for the entrypoints describing
+ * the results of their actions (see `getMethodReturnSchema`).
+ * @param def The schema of the result: a DTO class or a schema (`DTO.Number()`).
+ * @returns The method decorator; the decorated method cannot be reassigned.
+ * @throws {InvalidMethodReturnException} From a call, when the method returns `undefined` (whatever the schema), or a
+ * value which does not match the schema (its cause is the `InvalidValueException` of the validation).
+ * @example
+ * ```typescript
+ * import {Component, DTO} from 'lakutata'
+ * import {Expect, Return} from 'lakutata/decorator/dto'
+ *
+ * class UserDTO extends DTO {
+ *     @Expect(DTO.Number().integer().required())
+ *     public id!: number
+ *
+ *     @Expect(DTO.String().required())
+ *     public name!: string
+ * }
+ *
+ * declare const db: {
+ *     findUser(id: number): Promise<{id: number, name: string, passwordHash: string}>
+ * }
+ *
+ * class Users extends Component {
+ *     //The password hash is removed from the result: UserDTO has no schema for it
+ *     @Return(UserDTO)
+ *     public async find(id: number): Promise<{id: number, name: string}> {
+ *         return await db.findUser(id)
+ *     }
+ * }
+ * ```
+ */
+export declare function Return<ClassPrototype, DTOConstructor extends typeof DTO, Method>(def: DTOConstructor | Schema): MethodDecorator<ClassPrototype, Method>;

package/dist/types/dto/PaginationResultDTO.d.ts

@@ -0,0 +1,33 @@
+import { DTO } from '../lib/dto/DTO.js';
+import { type PaginationMeta } from '../types/PaginationMeta.js';
+/**
+ * The result of a paginated search: the items of the page, and where the page is in the whole result. `paginator()`
+ * builds it; use it with `@Return` to validate the result of a paginated action.
+ * @example
+ * ```typescript
+ * import {Component} from 'lakutata'
+ * import {Return} from 'lakutata/decorator/dto'
+ * import {PaginationResultDTO} from 'lakutata/dtos'
+ *
+ * class Tags extends Component {
+ *     protected readonly tags: string[] = ['red', 'green', 'blue']
+ *
+ *     @Return(PaginationResultDTO)
+ *     public async list(limit: number, offset: number): Promise<PaginationResultDTO<string>> {
+ *         const items: string[] = this.tags.slice(offset, offset + limit)
+ *         return {items: items, meta: {count: items.length, total: this.tags.length, limit: limit, offset: offset}}
+ *     }
+ * }
+ * ```
+ */
+export declare class PaginationResultDTO<T = any, U = T[]> extends DTO {
+    /**
+     * The items of the page (an array; its items are not validated).
+     */
+    items: U;
+    /**
+     * Where the page is: `count` the number of items of the page, `total` the number of items of the whole result,
+     * `limit` and `offset` those of the search. All integers, 0 or more.
+     */
+    meta: PaginationMeta;
+}

package/dist/types/dto/PaginationSearchDTO.d.ts

@@ -0,0 +1,33 @@
+import { DTO } from '../lib/dto/DTO.js';
+/**
+ * The input of a paginated search: how many items to return and how many to skip. Extend it with the search criteria,
+ * and pass the validated input to `paginator()`.
+ * @example
+ * ```typescript
+ * import {DTO} from 'lakutata'
+ * import {Expect} from 'lakutata/decorator/dto'
+ * import {PaginationSearchDTO} from 'lakutata/dtos'
+ *
+ * //Searching the users by name, a page at a time
+ * export class UserSearchDTO extends PaginationSearchDTO {
+ *     @Expect(DTO.String().optional())
+ *     public name?: string
+ * }
+ *
+ * //limit 10 and offset 0 by default
+ * const search: UserSearchDTO = new UserSearchDTO({name: 'ada'})
+ * console.log(search.limit, search.offset)
+ * ```
+ */
+export declare class PaginationSearchDTO extends DTO {
+    /**
+     * The maximum number of items to return: an integer, 0 or more.
+     * @default 10
+     */
+    limit?: number;
+    /**
+     * The number of items to skip before the first one returned: an integer, 0 or more.
+     * @default 0
+     */
+    offset?: number;
+}

package/dist/types/dto/Paginator.d.ts

@@ -0,0 +1,54 @@
+import { PaginationSearchDTO } from './PaginationSearchDTO.js';
+import { PaginationResultDTO } from './PaginationResultDTO.js';
+/**
+ * What the handler of `paginator()` returns: a page of items, and the size of the whole result.
+ */
+export interface PaginatorHandlerResult<T> {
+    /**
+     * The number of items of the whole result, across all the pages.
+     */
+    total: number;
+    /**
+     * The items of the page.
+     */
+    items: T[];
+}
+/**
+ * Fetch a page of items with a handler, and build the paginated result: the items, with the page metadata (`count`
+ * the number of items returned, `total` the handler's total, and the `limit` and `offset` of the search). It does not
+ * validate the search: pass a validated `PaginationSearchDTO` (the input of an action, or a constructed DTO), whose
+ * `limit` and `offset` have their defaults (10 and 0).
+ * @param options The search, a `PaginationSearchDTO` or a subclass carrying the search criteria.
+ * @param handler A function receiving the limit, the offset and the whole search, and resolving to the page of items
+ * and the total; its rejection rejects the paginator.
+ * @returns A promise of the paginated result (a plain object shaped as `PaginationResultDTO`).
+ * @example
+ * ```typescript
+ * import {DTO} from 'lakutata'
+ * import {Expect} from 'lakutata/decorator/dto'
+ * import {PaginationResultDTO, PaginationSearchDTO, paginator} from 'lakutata/dtos'
+ *
+ * class UserSearchDTO extends PaginationSearchDTO {
+ *     @Expect(DTO.String().optional())
+ *     public name?: string
+ * }
+ *
+ * interface User {
+ *     id: number
+ *     name: string
+ * }
+ *
+ * declare const db: {
+ *     countUsers(name?: string): Promise<number>
+ *     findUsers(name: string | undefined, limit: number, offset: number): Promise<User[]>
+ * }
+ *
+ * export async function SearchUsers(input: Record<string, unknown>): Promise<PaginationResultDTO<User>> {
+ *     return await paginator(new UserSearchDTO(input), async (limit: number, offset: number, search: UserSearchDTO) => ({
+ *         total: await db.countUsers(search.name),
+ *         items: await db.findUsers(search.name, limit, offset)
+ *     }))
+ * }
+ * ```
+ */
+export declare function paginator<Options extends PaginationSearchDTO, T>(options: Options, handler: (limit: number, offset: number, options: Options) => Promise<PaginatorHandlerResult<T>>): Promise<PaginationResultDTO<T>>;

package/dist/types/exceptions/DestroyRuntimeContainerException.d.ts

@@ -0,0 +1,10 @@
+import { Exception } from '../lib/foundation/Exception.js';
+/**
+ * A failure to destroy the application's root container, in 2.x. Its errno is `E_DESTROY_RUNTIME_CONTAINER`.
+ * @deprecated Never thrown since 3.0: the errors of the teardown of the objects are reported to the application's
+ * logger, and `Application.exit()` ends the process with the code 1 when the teardown fails. Kept for the code
+ * catching it; it will be removed.
+ */
+export declare class DestroyRuntimeContainerException extends Exception {
+    errno: string | number;
+}

package/dist/types/exceptions/InvalidActionPatternDepthException.d.ts

@@ -0,0 +1,8 @@
+import { Exception } from '../lib/foundation/Exception.js';
+/**
+ * Thrown when the pattern of a service action (`@ServiceAction`) nests objects more than 2 levels deep.
+ * Its errno is `E_INVALID_ACTION_PATTERN_DEPTH`.
+ */
+export declare class InvalidActionPatternDepthException extends Exception {
+    errno: string | number;
+}

package/dist/types/exceptions/InvalidAssistantFunctionTypeException.d.ts

@@ -0,0 +1,9 @@
+import { Exception } from '../lib/foundation/Exception.js';
+/**
+ * Thrown when a `@Before` or `@After` decorator is applied to a member which is not a method, or gives an
+ * async function to a method which is not async. Thrown when the class is defined. Its errno is
+ * `E_INVALID_ASSISTANT_FUNCTION_TYPE`.
+ */
+export declare class InvalidAssistantFunctionTypeException extends Exception {
+    errno: string | number;
+}

package/dist/types/exceptions/InvalidObjectTypeException.d.ts

@@ -0,0 +1,9 @@
+import { Exception } from '../lib/foundation/Exception.js';
+/**
+ * Thrown when an object is declared in the wrong module option (a provider in `components`, a module in
+ * `providers`…); its message names the right option. It fails the module's initialization. Its errno is
+ * `E_INVALID_OBJECT_TYPE`.
+ */
+export declare class InvalidObjectTypeException extends Exception {
+    errno: string | number;
+}

package/dist/types/exceptions/MethodNotFoundException.d.ts

@@ -0,0 +1,8 @@
+import { Exception } from '../lib/foundation/Exception.js';
+/**
+ * Thrown by `getMethod(name, true)` when the object has no method of this name. Its errno is
+ * `E_METHOD_NOT_FOUND`.
+ */
+export declare class MethodNotFoundException extends Exception {
+    errno: string | number;
+}

package/dist/types/exceptions/ObjectDestroyedException.d.ts

@@ -0,0 +1,9 @@
+import { Exception } from '../lib/foundation/Exception.js';
+/**
+ * Thrown when a destroyed (or being destroyed) object or container is used: `getObject()`,
+ * `buildObject()`, `createScope()`, `load()`, `get()`, or an initialization which a teardown interrupted. Its errno is
+ * `E_OBJECT_DESTROYED`.
+ */
+export declare class ObjectDestroyedException extends Exception {
+    errno: string | number;
+}

package/dist/types/exceptions/alias/AliasExistsException.d.ts

@@ -0,0 +1,8 @@
+import { Exception } from '../../lib/foundation/Exception.js';
+/**
+ * Thrown when a path alias is registered twice without override (`Application.alias()` declaring an alias
+ * already registered, which fails the launch). Its errno is `E_ALIAS_EXISTS`.
+ */
+export declare class AliasExistsException extends Exception {
+    errno: number | string;
+}

package/dist/types/exceptions/alias/AliasNotFoundException.d.ts

@@ -0,0 +1,8 @@
+import { Exception } from '../../lib/foundation/Exception.js';
+/**
+ * Thrown when a path alias is read (`app.alias.get()`) without being registered. Its errno is
+ * `E_ALIAS_NOT_FOUND`.
+ */
+export declare class AliasNotFoundException extends Exception {
+    errno: number | string;
+}

package/dist/types/exceptions/alias/InvalidAliasNameException.d.ts

@@ -0,0 +1,8 @@
+import { Exception } from '../../lib/foundation/Exception.js';
+/**
+ * Thrown when an alias name is not `@` followed by letters and digits only (`app.alias.set()`, `get()`,
+ * `has()`; an alias of `Application.alias()` fails the launch). Its errno is `E_INVALID_ALIAS_NAME`.
+ */
+export declare class InvalidAliasNameException extends Exception {
+    errno: number | string;
+}

package/dist/types/exceptions/di/DependencyInjectionException.d.ts

@@ -0,0 +1,9 @@
+import { Exception } from '../../lib/foundation/Exception.js';
+/**
+ * Thrown when an `@Inject` property of an object cannot be resolved (nothing registered under its name or
+ * class, or the dependency fails to be created), which fails the creation of the object. Its errno is
+ * `E_DEPENDENCY_INJECTION`; its message names the property, the class and the cause.
+ */
+export declare class DependencyInjectionException extends Exception {
+    errno: number | string;
+}

package/dist/types/exceptions/di/InvalidObjectOptionsException.d.ts

@@ -0,0 +1,9 @@
+import { Exception } from '../../lib/foundation/Exception.js';
+/**
+ * Thrown when a module initializes and an object it declares has an option whose value is invalid for its
+ * `@Configurable` property (see the `checkOptions` module option); its message lists every invalid option. It fails
+ * the module's initialization. Its errno is `E_INVALID_OBJECT_OPTIONS`.
+ */
+export declare class InvalidObjectOptionsException extends Exception {
+    errno: string | number;
+}

package/dist/types/exceptions/di/LifetimeLockedException.d.ts

@@ -0,0 +1,9 @@
+import { Exception } from '../../lib/foundation/Exception.js';
+/**
+ * Thrown when a class declares a lifetime its parent class has locked (a component or module declared
+ * `@Transient` or `@Scoped`, a controller declared `@Singleton` or `@Transient`). Thrown when the class is defined. Its
+ * errno is `E_LIFETIME_LOCKED`.
+ */
+export declare class LifetimeLockedException extends Exception {
+    errno: string | number;
+}

package/dist/types/exceptions/di/OverridableObjectTargetConfigNotFoundException.d.ts

@@ -0,0 +1,9 @@
+import { Exception } from '../../lib/foundation/Exception.js';
+/**
+ * Thrown when a component or provider is declared without class in the module options while no
+ * component or provider of the same name is declared by the module's initializer or by `Application.preset()` to
+ * complete; it fails the module's initialization. Its errno is `E_OVERRIDABLE_OBJECT_TARGET_CONFIG_NOT_FOUND`.
+ */
+export declare class OverridableObjectTargetConfigNotFoundException extends Exception {
+    errno: string | number;
+}

package/dist/types/exceptions/dto/InvalidMethodAcceptException.d.ts

@@ -0,0 +1,9 @@
+import { Exception } from '../../lib/foundation/Exception.js';
+/**
+ * Thrown by a method decorated with `@Accept` when an argument does not match its schema (an async method rejects with
+ * it); its message names the method and the invalid argument, its cause is the `InvalidValueException` of the
+ * validation. Its `errno` is `E_INVALID_METHOD_ACCEPT`.
+ */
+export declare class InvalidMethodAcceptException extends Exception {
+    errno: number | string;
+}

package/dist/types/exceptions/dto/InvalidMethodReturnException.d.ts

@@ -0,0 +1,9 @@
+import { Exception } from '../../lib/foundation/Exception.js';
+/**
+ * Thrown by a method decorated with `@Return` when it returns `undefined`, or a value which does not match its schema
+ * (an async method rejects with it); its cause is then the `InvalidValueException` of the validation. Its `errno` is
+ * `E_INVALID_METHOD_RETURN`.
+ */
+export declare class InvalidMethodReturnException extends Exception {
+    errno: number | string;
+}

package/dist/types/exceptions/dto/InvalidValueException.d.ts

@@ -0,0 +1,11 @@
+import { Exception } from '../../lib/foundation/Exception.js';
+/**
+ * Thrown when a value does not match its schema: by `DTO.validate()` and `DTO.validateAsync()`, by the DTO constructor
+ * and the assignments to a DTO property, and by the creation of an object whose `@Configurable` value is invalid. Its
+ * message describes the first error; its causes lead to the `SchemaValidationException` holding the details (the path
+ * and the rule of each error). Its `errno` is `E_INVALID_VALUE`; the HTTP entrypoints answer an invalid action input with the
+ * status 400, JSON-RPC with the error "invalid params".
+ */
+export declare class InvalidValueException extends Exception {
+    errno: string | number;
+}

package/dist/types/exports/ASSTDecorators.d.ts

@@ -0,0 +1,3 @@
+import 'reflect-metadata';
+export { After } from '../decorators/asst/After.js';
+export { Before } from '../decorators/asst/Before.js';