@elysiumjs/core 0.8.0 → 0.11.0

package/dist/problem.d.ts

@@ -0,0 +1,815 @@
+import { HTTPError } from 'elysia';
+/**
+ * An error response in the RFC 9457 "problem details" format, sent as
+ * `application/problem+json`. Extension members sit at the top level, next to the standard ones.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export type ProblemDetails = {
+    /** A URI reference that identifies the problem type: the slug of its code, under `typeBase`. */
+    type: string;
+    /** A short summary of the problem type. */
+    title: string;
+    /** The HTTP status code. */
+    status: number;
+    /** The stable machine-readable code of the problem, such as `NOT_FOUND`. */
+    code?: string;
+    /** An explanation specific to this occurrence. */
+    detail?: string;
+    /** A URI reference that identifies this occurrence: the request path. */
+    instance?: string;
+    /** The id of the request, to find it in the logs. */
+    requestId?: string;
+    [extension: string]: unknown;
+};
+/**
+ * One invalid value of a request, in the `errors` member of a validation problem.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export type ProblemValidationError = {
+    /** A JSON Pointer (RFC 6901) to the value, rooted at the request part: `/body/email`. */
+    pointer: string;
+    /** What is wrong with it. */
+    message: string;
+    /** The rule that failed, such as `format` or `requiredProperties`. */
+    code?: string;
+};
+/**
+ * Options of the problem details rendering, set with `problems` on `@Application.register()`.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export type ProblemOptions = {
+    /**
+     * The base of every problem `type`, such as `https://api.example.com/problems`: a problem of
+     * code `INSUFFICIENT_FUNDS` gets `https://api.example.com/problems/insufficient-funds`. Without
+     * it, `type` is the slug alone.
+     */
+    typeBase?: string;
+    /** The status of request validation errors. Defaults to 422. */
+    validationStatus?: 400 | 422;
+    /**
+     * The id of a request, served as `requestId` in its problems. Defaults to a valid
+     * `x-request-id` header, or a random UUID.
+     */
+    requestId?: (request: Request) => string;
+};
+/** The MIME type of problem details responses. */
+export declare const PROBLEM_CONTENT_TYPE = "application/problem+json";
+/**
+ * The standard reason phrase of an HTTP status, used as the default problem title.
+ * @author Axel Nana <axel.nana@workbud.com>
+ * @param status The HTTP status code.
+ */
+export declare const statusTitle: (status: number) => string;
+/**
+ * The problem codes of the application, declared by merging into this interface: one key per code.
+ * Once it has keys, `DomainError.for()` takes only those codes and the ones of the framework
+ * ({@link ElysiumProblemCode}); while it has none, any string is a code.
+ * @author Axel Nana <axel.nana@workbud.com>
+ * @example
+ * ```ts
+ * declare module '@elysiumjs/core' {
+ *   interface ProblemCatalogue {
+ *     INSUFFICIENT_FUNDS: true;
+ *     ACCOUNT_CLOSED: true;
+ *   }
+ * }
+ * ```
+ */
+export interface ProblemCatalogue {
+}
+/**
+ * The problem codes the framework packages answer with. An application that keeps its own
+ * catalogue lists them too, so that its clients know every code.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export declare const ELYSIUM_PROBLEM_CODES: {
+    /** 400: a request that cannot be read, such as a malformed body or invalid query. */
+    readonly BAD_REQUEST: 'BAD_REQUEST';
+    /** 400 or 422: request values that do not match their schema; carries `errors`. */
+    readonly VALIDATION_FAILED: 'VALIDATION_FAILED';
+    /** 401: the request has no valid credentials. */
+    readonly UNAUTHENTICATED: 'UNAUTHENTICATED';
+    /** 403: the caller may not do this. */
+    readonly FORBIDDEN: 'FORBIDDEN';
+    /** 404: no such resource or route. */
+    readonly NOT_FOUND: 'NOT_FOUND';
+    /** 409: the request conflicts with the current state. */
+    readonly CONFLICT: 'CONFLICT';
+    /** 413: the body is larger than the body limit. */
+    readonly PAYLOAD_TOO_LARGE: 'PAYLOAD_TOO_LARGE';
+    /** 429: carries `retryAfter` and the Retry-After header. */
+    readonly RATE_LIMITED: 'RATE_LIMITED';
+    /** 500: an unexpected failure. */
+    readonly INTERNAL_ERROR: 'INTERNAL_ERROR';
+    /** 403: the CSRF token of a cookie session is missing or does not match (themis). */
+    readonly CSRF_TOKEN_MISMATCH: 'CSRF_TOKEN_MISMATCH';
+    /** 403: a signed URL whose signature does not verify, or that expired (themis). */
+    readonly INVALID_SIGNATURE: 'INVALID_SIGNATURE';
+    /** 400: a passkey ceremony that did not verify (themis). */
+    readonly PASSKEY_VERIFICATION_FAILED: 'PASSKEY_VERIFICATION_FAILED';
+    /** 400: an OAuth sign-in that could not complete (themis). */
+    readonly OAUTH_CALLBACK_FAILED: 'OAUTH_CALLBACK_FAILED';
+    /** 428: an idempotent command called without an Idempotency-Key (moirai). */
+    readonly IDEMPOTENCY_KEY_REQUIRED: 'IDEMPOTENCY_KEY_REQUIRED';
+    /** 422: an Idempotency-Key used before for another request (moirai). */
+    readonly IDEMPOTENCY_KEY_REUSED: 'IDEMPOTENCY_KEY_REUSED';
+    /** 410: the flow does not exist or expired (ariadne). */
+    readonly FLOW_EXPIRED: 'FLOW_EXPIRED';
+    /** 410: the flow is finished (ariadne). */
+    readonly FLOW_COMPLETED: 'FLOW_COMPLETED';
+    /** 409: a step the flow does not accept now; carries `nextSteps`, `backSteps`, `answer` (ariadne). */
+    readonly FLOW_UNEXPECTED_STEP: 'FLOW_UNEXPECTED_STEP';
+    /** 409: another request is running the same step (ariadne). */
+    readonly FLOW_STEP_IN_PROGRESS: 'FLOW_STEP_IN_PROGRESS';
+};
+/**
+ * A problem code of the framework.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export type ElysiumProblemCode = keyof typeof ELYSIUM_PROBLEM_CODES;
+/**
+ * A problem code: one of {@link ProblemCatalogue} or of the framework, or any string while the
+ * catalogue is empty.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export type ProblemCode = [keyof ProblemCatalogue] extends [never] ? string : (keyof ProblemCatalogue & string) | ElysiumProblemCode;
+/**
+ * The `type` of a problem code: its kebab-case slug, under the base when one is set.
+ * `INSUFFICIENT_FUNDS` gives `insufficient-funds`, or `https://api.example.com/problems/insufficient-funds`.
+ * @author Axel Nana <axel.nana@workbud.com>
+ * @param code The problem code.
+ * @param base The `typeBase` of the application.
+ */
+export declare const problemType: (code: string, base?: string) => string;
+/**
+ * The options of a {@link DomainError}.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export type DomainErrorOptions = {
+    /** The invalid values, served as `errors`. */
+    errors?: readonly ProblemValidationError[];
+    /** Seconds until the client may retry, served as `retryAfter` and the Retry-After header. */
+    retryAfterSeconds?: number;
+    /** Extra members of the problem; the standard members win over them. */
+    extensions?: Readonly<Record<string, unknown>>;
+    /** A title of its own. Defaults to the reason phrase of the status. */
+    title?: string;
+    /** The error that caused this one, kept for logs. */
+    cause?: unknown;
+};
+/**
+ * An error the application expects and reports to the client as problem details, and an Elysia
+ * `HTTPError`. Each error is a class of its own, made with `DomainError.for(code, status)`, so a
+ * signature names what can go wrong (`Promise<Account | AccountClosed>`).
+ *
+ * Handlers, commands, queries and flow steps return it (errors as values) or throw it; both send
+ * the same problem, roll back the unit of work, and commit nothing. A returned error joins the
+ * route's response type under its literal status, so typed clients see it. `message` is the
+ * detail shown to the client.
+ * @author Axel Nana <axel.nana@workbud.com>
+ * @template C The problem code.
+ * @template S The HTTP status.
+ * @example
+ * ```ts
+ * export class InsufficientFunds extends DomainError.for('INSUFFICIENT_FUNDS', 409) {
+ *   constructor(missing: number) {
+ *     super(`${missing} more are needed.`, { extensions: { missing } });
+ *   }
+ * }
+ *
+ * public async pay(amount: number): Promise<Receipt | InsufficientFunds> {
+ *   if (balance < amount) return new InsufficientFunds(amount - balance);
+ *   ...
+ * }
+ * ```
+ */
+export declare abstract class DomainError<C extends string = string, S extends number = number> extends HTTPError {
+    /** The base of `type`, set from `problems.typeBase` of the application. */
+    static typeBase?: string;
+    readonly code: C;
+    readonly status: S;
+    /** The detail shown to the client; undefined when none was given. */
+    readonly detail: string | undefined;
+    readonly title: string;
+    readonly errors: readonly ProblemValidationError[] | undefined;
+    readonly retryAfterSeconds: number | undefined;
+    readonly extensions: Readonly<Record<string, unknown>>;
+    readonly headers: Record<string, string> | undefined;
+    /** Protected: an error is created through its own class, made with `DomainError.for()`. */
+    protected constructor(code: C, status: S, detail?: string, options?: DomainErrorOptions);
+    /** The problem type: the slug of the code, under `typeBase`. */
+    get type(): string;
+    /**
+     * The base class of one error, with its code and status kept as literal types.
+     * @param code The problem code, from the {@link ProblemCatalogue} once it has keys.
+     * @param status The HTTP status.
+     */
+    static for<const C extends ProblemCode, const S extends number>(code: C, status: S): {
+        new (detail?: string, options?: DomainErrorOptions): {
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+            value?(): import("elysia/types").MaybePromise<unknown>;
+            readonly code: C;
+            readonly status: S;
+            /** The detail shown to the client; undefined when none was given. */
+            readonly detail: string | undefined;
+            readonly title: string;
+            readonly errors: readonly ProblemValidationError[] | undefined;
+            readonly retryAfterSeconds: number | undefined;
+            readonly extensions: Readonly<Record<string, unknown>>;
+            readonly headers: Record<string, string> | undefined;
+            /** The problem type: the slug of the code, under `typeBase`. */
+            get type(): string;
+            /** The members besides type, code, status and detail: the extensions first, so that the standard ones win. */
+            extension(): Record<string, unknown>;
+        };
+        isError(error: unknown): error is Error;
+        isError(value: unknown): value is Error;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+        id<const Type extends string>(code: Type): import("elysia").TaggedHTTPError<Type>;
+        id<const Type extends string, const S_1 extends number | keyof import("elysia").StatusMap>(code: Type, status: S_1): import("elysia").TaggedHTTPError<Type, {
+            readonly status: S_1 extends keyof import("elysia").StatusMap ? import("elysia").StatusMap[S_1] : S_1;
+        }>;
+        /** The base of `type`, set from `problems.typeBase` of the application. */
+        typeBase?: string;
+        for<const C extends ProblemCode, const S extends number>(code: C, status: S): /*elided*/ any;
+    };
+    /** The members besides type, code, status and detail: the extensions first, so that the standard ones win. */
+    extension(): Record<string, unknown>;
+}
+/**
+ * Checks whether a value is a {@link DomainError}, such as the result of a command.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export declare const isDomainError: (value: unknown) => value is DomainError;
+declare const BadRequestError_base: {
+    new (detail?: string, options?: DomainErrorOptions): {
+        name: string;
+        message: string;
+        stack?: string;
+        cause?: unknown;
+        value?(): import("elysia/types").MaybePromise<unknown>;
+        readonly code: "BAD_REQUEST";
+        readonly status: 400;
+        /** The detail shown to the client; undefined when none was given. */
+        readonly detail: string | undefined;
+        readonly title: string;
+        readonly errors: readonly ProblemValidationError[] | undefined;
+        readonly retryAfterSeconds: number | undefined;
+        readonly extensions: Readonly<Record<string, unknown>>;
+        readonly headers: Record<string, string> | undefined;
+        /** The problem type: the slug of the code, under `typeBase`. */
+        get type(): string;
+        /** The members besides type, code, status and detail: the extensions first, so that the standard ones win. */
+        extension(): Record<string, unknown>;
+    };
+    isError(error: unknown): error is Error;
+    isError(value: unknown): value is Error;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+    id<const Type extends string>(code: Type): import("elysia").TaggedHTTPError<Type>;
+    id<const Type extends string, const S extends number | keyof import("elysia").StatusMap>(code: Type, status: S): import("elysia").TaggedHTTPError<Type, {
+        readonly status: S extends keyof import("elysia").StatusMap ? import("elysia").StatusMap[S] : S;
+    }>;
+    /** The base of `type`, set from `problems.typeBase` of the application. */
+    typeBase?: string;
+    /**
+     * The base class of one error, with its code and status kept as literal types.
+     * @param code The problem code, from the {@link ProblemCatalogue} once it has keys.
+     * @param status The HTTP status.
+     */
+    for<const C extends ProblemCode, const S extends number>(code: C, status: S): {
+        new (detail?: string, options?: DomainErrorOptions): {
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+            value?(): import("elysia/types").MaybePromise<unknown>;
+            readonly code: C;
+            readonly status: S;
+            /** The detail shown to the client; undefined when none was given. */
+            readonly detail: string | undefined;
+            readonly title: string;
+            readonly errors: readonly ProblemValidationError[] | undefined;
+            readonly retryAfterSeconds: number | undefined;
+            readonly extensions: Readonly<Record<string, unknown>>;
+            readonly headers: Record<string, string> | undefined;
+            /** The problem type: the slug of the code, under `typeBase`. */
+            get type(): string;
+            /** The members besides type, code, status and detail: the extensions first, so that the standard ones win. */
+            extension(): Record<string, unknown>;
+        };
+        isError(error: unknown): error is Error;
+        isError(value: unknown): value is Error;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+        id<const Type extends string>(code: Type): import("elysia").TaggedHTTPError<Type>;
+        id<const Type extends string, const S_1 extends number | keyof import("elysia").StatusMap>(code: Type, status: S_1): import("elysia").TaggedHTTPError<Type, {
+            readonly status: S_1 extends keyof import("elysia").StatusMap ? import("elysia").StatusMap[S_1] : S_1;
+        }>;
+        /** The base of `type`, set from `problems.typeBase` of the application. */
+        typeBase?: string;
+        for<const C extends ProblemCode, const S extends number>(code: C, status: S): /*elided*/ any;
+    };
+};
+/**
+ * A request that cannot be read: a 400 problem.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export declare class BadRequestError extends BadRequestError_base {
+}
+declare const ValidationFailedError_base: {
+    new (detail?: string, options?: DomainErrorOptions): {
+        name: string;
+        message: string;
+        stack?: string;
+        cause?: unknown;
+        value?(): import("elysia/types").MaybePromise<unknown>;
+        readonly code: "VALIDATION_FAILED";
+        readonly status: 422;
+        /** The detail shown to the client; undefined when none was given. */
+        readonly detail: string | undefined;
+        readonly title: string;
+        readonly errors: readonly ProblemValidationError[] | undefined;
+        readonly retryAfterSeconds: number | undefined;
+        readonly extensions: Readonly<Record<string, unknown>>;
+        readonly headers: Record<string, string> | undefined;
+        /** The problem type: the slug of the code, under `typeBase`. */
+        get type(): string;
+        /** The members besides type, code, status and detail: the extensions first, so that the standard ones win. */
+        extension(): Record<string, unknown>;
+    };
+    isError(error: unknown): error is Error;
+    isError(value: unknown): value is Error;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+    id<const Type extends string>(code: Type): import("elysia").TaggedHTTPError<Type>;
+    id<const Type extends string, const S extends number | keyof import("elysia").StatusMap>(code: Type, status: S): import("elysia").TaggedHTTPError<Type, {
+        readonly status: S extends keyof import("elysia").StatusMap ? import("elysia").StatusMap[S] : S;
+    }>;
+    /** The base of `type`, set from `problems.typeBase` of the application. */
+    typeBase?: string;
+    /**
+     * The base class of one error, with its code and status kept as literal types.
+     * @param code The problem code, from the {@link ProblemCatalogue} once it has keys.
+     * @param status The HTTP status.
+     */
+    for<const C extends ProblemCode, const S extends number>(code: C, status: S): {
+        new (detail?: string, options?: DomainErrorOptions): {
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+            value?(): import("elysia/types").MaybePromise<unknown>;
+            readonly code: C;
+            readonly status: S;
+            /** The detail shown to the client; undefined when none was given. */
+            readonly detail: string | undefined;
+            readonly title: string;
+            readonly errors: readonly ProblemValidationError[] | undefined;
+            readonly retryAfterSeconds: number | undefined;
+            readonly extensions: Readonly<Record<string, unknown>>;
+            readonly headers: Record<string, string> | undefined;
+            /** The problem type: the slug of the code, under `typeBase`. */
+            get type(): string;
+            /** The members besides type, code, status and detail: the extensions first, so that the standard ones win. */
+            extension(): Record<string, unknown>;
+        };
+        isError(error: unknown): error is Error;
+        isError(value: unknown): value is Error;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+        id<const Type extends string>(code: Type): import("elysia").TaggedHTTPError<Type>;
+        id<const Type extends string, const S_1 extends number | keyof import("elysia").StatusMap>(code: Type, status: S_1): import("elysia").TaggedHTTPError<Type, {
+            readonly status: S_1 extends keyof import("elysia").StatusMap ? import("elysia").StatusMap[S_1] : S_1;
+        }>;
+        /** The base of `type`, set from `problems.typeBase` of the application. */
+        typeBase?: string;
+        for<const C extends ProblemCode, const S extends number>(code: C, status: S): /*elided*/ any;
+    };
+};
+/**
+ * Request values that do not match their schema: a 422 problem with one entry per mistake.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export declare class ValidationFailedError extends ValidationFailedError_base {
+    constructor(errors: readonly ProblemValidationError[], detail?: string);
+}
+declare const UnauthenticatedError_base: {
+    new (detail?: string, options?: DomainErrorOptions): {
+        name: string;
+        message: string;
+        stack?: string;
+        cause?: unknown;
+        value?(): import("elysia/types").MaybePromise<unknown>;
+        readonly code: "UNAUTHENTICATED";
+        readonly status: 401;
+        /** The detail shown to the client; undefined when none was given. */
+        readonly detail: string | undefined;
+        readonly title: string;
+        readonly errors: readonly ProblemValidationError[] | undefined;
+        readonly retryAfterSeconds: number | undefined;
+        readonly extensions: Readonly<Record<string, unknown>>;
+        readonly headers: Record<string, string> | undefined;
+        /** The problem type: the slug of the code, under `typeBase`. */
+        get type(): string;
+        /** The members besides type, code, status and detail: the extensions first, so that the standard ones win. */
+        extension(): Record<string, unknown>;
+    };
+    isError(error: unknown): error is Error;
+    isError(value: unknown): value is Error;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+    id<const Type extends string>(code: Type): import("elysia").TaggedHTTPError<Type>;
+    id<const Type extends string, const S extends number | keyof import("elysia").StatusMap>(code: Type, status: S): import("elysia").TaggedHTTPError<Type, {
+        readonly status: S extends keyof import("elysia").StatusMap ? import("elysia").StatusMap[S] : S;
+    }>;
+    /** The base of `type`, set from `problems.typeBase` of the application. */
+    typeBase?: string;
+    /**
+     * The base class of one error, with its code and status kept as literal types.
+     * @param code The problem code, from the {@link ProblemCatalogue} once it has keys.
+     * @param status The HTTP status.
+     */
+    for<const C extends ProblemCode, const S extends number>(code: C, status: S): {
+        new (detail?: string, options?: DomainErrorOptions): {
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+            value?(): import("elysia/types").MaybePromise<unknown>;
+            readonly code: C;
+            readonly status: S;
+            /** The detail shown to the client; undefined when none was given. */
+            readonly detail: string | undefined;
+            readonly title: string;
+            readonly errors: readonly ProblemValidationError[] | undefined;
+            readonly retryAfterSeconds: number | undefined;
+            readonly extensions: Readonly<Record<string, unknown>>;
+            readonly headers: Record<string, string> | undefined;
+            /** The problem type: the slug of the code, under `typeBase`. */
+            get type(): string;
+            /** The members besides type, code, status and detail: the extensions first, so that the standard ones win. */
+            extension(): Record<string, unknown>;
+        };
+        isError(error: unknown): error is Error;
+        isError(value: unknown): value is Error;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+        id<const Type extends string>(code: Type): import("elysia").TaggedHTTPError<Type>;
+        id<const Type extends string, const S_1 extends number | keyof import("elysia").StatusMap>(code: Type, status: S_1): import("elysia").TaggedHTTPError<Type, {
+            readonly status: S_1 extends keyof import("elysia").StatusMap ? import("elysia").StatusMap[S_1] : S_1;
+        }>;
+        /** The base of `type`, set from `problems.typeBase` of the application. */
+        typeBase?: string;
+        for<const C extends ProblemCode, const S extends number>(code: C, status: S): /*elided*/ any;
+    };
+};
+/**
+ * A request without valid credentials: a 401 problem.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export declare class UnauthenticatedError extends UnauthenticatedError_base {
+    constructor(detail?: string);
+}
+declare const ForbiddenError_base: {
+    new (detail?: string, options?: DomainErrorOptions): {
+        name: string;
+        message: string;
+        stack?: string;
+        cause?: unknown;
+        value?(): import("elysia/types").MaybePromise<unknown>;
+        readonly code: "FORBIDDEN";
+        readonly status: 403;
+        /** The detail shown to the client; undefined when none was given. */
+        readonly detail: string | undefined;
+        readonly title: string;
+        readonly errors: readonly ProblemValidationError[] | undefined;
+        readonly retryAfterSeconds: number | undefined;
+        readonly extensions: Readonly<Record<string, unknown>>;
+        readonly headers: Record<string, string> | undefined;
+        /** The problem type: the slug of the code, under `typeBase`. */
+        get type(): string;
+        /** The members besides type, code, status and detail: the extensions first, so that the standard ones win. */
+        extension(): Record<string, unknown>;
+    };
+    isError(error: unknown): error is Error;
+    isError(value: unknown): value is Error;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+    id<const Type extends string>(code: Type): import("elysia").TaggedHTTPError<Type>;
+    id<const Type extends string, const S extends number | keyof import("elysia").StatusMap>(code: Type, status: S): import("elysia").TaggedHTTPError<Type, {
+        readonly status: S extends keyof import("elysia").StatusMap ? import("elysia").StatusMap[S] : S;
+    }>;
+    /** The base of `type`, set from `problems.typeBase` of the application. */
+    typeBase?: string;
+    /**
+     * The base class of one error, with its code and status kept as literal types.
+     * @param code The problem code, from the {@link ProblemCatalogue} once it has keys.
+     * @param status The HTTP status.
+     */
+    for<const C extends ProblemCode, const S extends number>(code: C, status: S): {
+        new (detail?: string, options?: DomainErrorOptions): {
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+            value?(): import("elysia/types").MaybePromise<unknown>;
+            readonly code: C;
+            readonly status: S;
+            /** The detail shown to the client; undefined when none was given. */
+            readonly detail: string | undefined;
+            readonly title: string;
+            readonly errors: readonly ProblemValidationError[] | undefined;
+            readonly retryAfterSeconds: number | undefined;
+            readonly extensions: Readonly<Record<string, unknown>>;
+            readonly headers: Record<string, string> | undefined;
+            /** The problem type: the slug of the code, under `typeBase`. */
+            get type(): string;
+            /** The members besides type, code, status and detail: the extensions first, so that the standard ones win. */
+            extension(): Record<string, unknown>;
+        };
+        isError(error: unknown): error is Error;
+        isError(value: unknown): value is Error;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+        id<const Type extends string>(code: Type): import("elysia").TaggedHTTPError<Type>;
+        id<const Type extends string, const S_1 extends number | keyof import("elysia").StatusMap>(code: Type, status: S_1): import("elysia").TaggedHTTPError<Type, {
+            readonly status: S_1 extends keyof import("elysia").StatusMap ? import("elysia").StatusMap[S_1] : S_1;
+        }>;
+        /** The base of `type`, set from `problems.typeBase` of the application. */
+        typeBase?: string;
+        for<const C extends ProblemCode, const S extends number>(code: C, status: S): /*elided*/ any;
+    };
+};
+/**
+ * A caller that may not do this: a 403 problem.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export declare class ForbiddenError extends ForbiddenError_base {
+}
+declare const NotFoundError_base: {
+    new (detail?: string, options?: DomainErrorOptions): {
+        name: string;
+        message: string;
+        stack?: string;
+        cause?: unknown;
+        value?(): import("elysia/types").MaybePromise<unknown>;
+        readonly code: "NOT_FOUND";
+        readonly status: 404;
+        /** The detail shown to the client; undefined when none was given. */
+        readonly detail: string | undefined;
+        readonly title: string;
+        readonly errors: readonly ProblemValidationError[] | undefined;
+        readonly retryAfterSeconds: number | undefined;
+        readonly extensions: Readonly<Record<string, unknown>>;
+        readonly headers: Record<string, string> | undefined;
+        /** The problem type: the slug of the code, under `typeBase`. */
+        get type(): string;
+        /** The members besides type, code, status and detail: the extensions first, so that the standard ones win. */
+        extension(): Record<string, unknown>;
+    };
+    isError(error: unknown): error is Error;
+    isError(value: unknown): value is Error;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+    id<const Type extends string>(code: Type): import("elysia").TaggedHTTPError<Type>;
+    id<const Type extends string, const S extends number | keyof import("elysia").StatusMap>(code: Type, status: S): import("elysia").TaggedHTTPError<Type, {
+        readonly status: S extends keyof import("elysia").StatusMap ? import("elysia").StatusMap[S] : S;
+    }>;
+    /** The base of `type`, set from `problems.typeBase` of the application. */
+    typeBase?: string;
+    /**
+     * The base class of one error, with its code and status kept as literal types.
+     * @param code The problem code, from the {@link ProblemCatalogue} once it has keys.
+     * @param status The HTTP status.
+     */
+    for<const C extends ProblemCode, const S extends number>(code: C, status: S): {
+        new (detail?: string, options?: DomainErrorOptions): {
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+            value?(): import("elysia/types").MaybePromise<unknown>;
+            readonly code: C;
+            readonly status: S;
+            /** The detail shown to the client; undefined when none was given. */
+            readonly detail: string | undefined;
+            readonly title: string;
+            readonly errors: readonly ProblemValidationError[] | undefined;
+            readonly retryAfterSeconds: number | undefined;
+            readonly extensions: Readonly<Record<string, unknown>>;
+            readonly headers: Record<string, string> | undefined;
+            /** The problem type: the slug of the code, under `typeBase`. */
+            get type(): string;
+            /** The members besides type, code, status and detail: the extensions first, so that the standard ones win. */
+            extension(): Record<string, unknown>;
+        };
+        isError(error: unknown): error is Error;
+        isError(value: unknown): value is Error;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+        id<const Type extends string>(code: Type): import("elysia").TaggedHTTPError<Type>;
+        id<const Type extends string, const S_1 extends number | keyof import("elysia").StatusMap>(code: Type, status: S_1): import("elysia").TaggedHTTPError<Type, {
+            readonly status: S_1 extends keyof import("elysia").StatusMap ? import("elysia").StatusMap[S_1] : S_1;
+        }>;
+        /** The base of `type`, set from `problems.typeBase` of the application. */
+        typeBase?: string;
+        for<const C extends ProblemCode, const S extends number>(code: C, status: S): /*elided*/ any;
+    };
+};
+/**
+ * A resource that does not exist: a 404 problem.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export declare class NotFoundError extends NotFoundError_base {
+}
+declare const ConflictError_base: {
+    new (detail?: string, options?: DomainErrorOptions): {
+        name: string;
+        message: string;
+        stack?: string;
+        cause?: unknown;
+        value?(): import("elysia/types").MaybePromise<unknown>;
+        readonly code: "CONFLICT";
+        readonly status: 409;
+        /** The detail shown to the client; undefined when none was given. */
+        readonly detail: string | undefined;
+        readonly title: string;
+        readonly errors: readonly ProblemValidationError[] | undefined;
+        readonly retryAfterSeconds: number | undefined;
+        readonly extensions: Readonly<Record<string, unknown>>;
+        readonly headers: Record<string, string> | undefined;
+        /** The problem type: the slug of the code, under `typeBase`. */
+        get type(): string;
+        /** The members besides type, code, status and detail: the extensions first, so that the standard ones win. */
+        extension(): Record<string, unknown>;
+    };
+    isError(error: unknown): error is Error;
+    isError(value: unknown): value is Error;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+    id<const Type extends string>(code: Type): import("elysia").TaggedHTTPError<Type>;
+    id<const Type extends string, const S extends number | keyof import("elysia").StatusMap>(code: Type, status: S): import("elysia").TaggedHTTPError<Type, {
+        readonly status: S extends keyof import("elysia").StatusMap ? import("elysia").StatusMap[S] : S;
+    }>;
+    /** The base of `type`, set from `problems.typeBase` of the application. */
+    typeBase?: string;
+    /**
+     * The base class of one error, with its code and status kept as literal types.
+     * @param code The problem code, from the {@link ProblemCatalogue} once it has keys.
+     * @param status The HTTP status.
+     */
+    for<const C extends ProblemCode, const S extends number>(code: C, status: S): {
+        new (detail?: string, options?: DomainErrorOptions): {
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+            value?(): import("elysia/types").MaybePromise<unknown>;
+            readonly code: C;
+            readonly status: S;
+            /** The detail shown to the client; undefined when none was given. */
+            readonly detail: string | undefined;
+            readonly title: string;
+            readonly errors: readonly ProblemValidationError[] | undefined;
+            readonly retryAfterSeconds: number | undefined;
+            readonly extensions: Readonly<Record<string, unknown>>;
+            readonly headers: Record<string, string> | undefined;
+            /** The problem type: the slug of the code, under `typeBase`. */
+            get type(): string;
+            /** The members besides type, code, status and detail: the extensions first, so that the standard ones win. */
+            extension(): Record<string, unknown>;
+        };
+        isError(error: unknown): error is Error;
+        isError(value: unknown): value is Error;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+        id<const Type extends string>(code: Type): import("elysia").TaggedHTTPError<Type>;
+        id<const Type extends string, const S_1 extends number | keyof import("elysia").StatusMap>(code: Type, status: S_1): import("elysia").TaggedHTTPError<Type, {
+            readonly status: S_1 extends keyof import("elysia").StatusMap ? import("elysia").StatusMap[S_1] : S_1;
+        }>;
+        /** The base of `type`, set from `problems.typeBase` of the application. */
+        typeBase?: string;
+        for<const C extends ProblemCode, const S extends number>(code: C, status: S): /*elided*/ any;
+    };
+};
+/**
+ * A request that conflicts with the current state: a 409 problem.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export declare class ConflictError extends ConflictError_base {
+}
+/**
+ * Checks whether a value is a problem details object: a `status` number and a `title` string.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export declare const isProblemDetails: (value: unknown) => value is ProblemDetails;
+/**
+ * Elysia wraps anything thrown while parsing the body (such as a body over the size limit) in a
+ * parse error. Returns the wrapped error when it is a {@link DomainError}, so that it keeps its
+ * own status, and the error itself otherwise.
+ * @author Axel Nana <axel.nana@workbud.com>
+ * @param error The thrown value.
+ */
+export declare const unwrapParseError: (error: unknown) => unknown;
+/**
+ * Turns the errors of an Elysia validation error into problem `errors`, one per invalid value.
+ * A missing required property is reported at the property's own pointer.
+ * @author Axel Nana <axel.nana@workbud.com>
+ * @param part The request part: `body`, `query`, `params`, `headers` or `cookie`.
+ * @param errors The validator errors (`ValidationError.all`).
+ */
+export declare const validationErrors: (part: string, errors: unknown[]) => ProblemValidationError[];
+/**
+ * The context {@link toProblem} needs about the request and the application.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export type ProblemContext = Omit<ProblemOptions, 'requestId'> & {
+    /** The request path, used as `instance`. */
+    path?: string;
+    /** The id of the request, served as `requestId`. */
+    requestId?: string;
+    /** Whether to include the detail and the stack of server errors. */
+    development: boolean;
+};
+/**
+ * The id of a request: the one `make` gives, a valid `x-request-id` header, or a random UUID.
+ * The same request always gets the same id.
+ * @author Axel Nana <axel.nana@workbud.com>
+ * @param request The request.
+ * @param make The `requestId` option of the application.
+ */
+export declare const requestIdOf: (request: Request, make?: (request: Request) => string) => string;
+/**
+ * Turns any error thrown or returned while handling a request into problem details. Every problem
+ * carries `code`, and the `requestId` and `instance` of the request when they are known.
+ *
+ * - A {@link DomainError} keeps its code, status, title, detail and members.
+ * - Elysia's request validation errors give `VALIDATION_FAILED` at `validationStatus` (422), with
+ *   an `errors` list.
+ * - Elysia's not found, parse and invalid cookie signature errors give `NOT_FOUND` (404) and
+ *   `BAD_REQUEST` (400).
+ * - Anything else is an `INTERNAL_ERROR` (500) whose detail and stack are only shown in
+ *   development.
+ * @author Axel Nana <axel.nana@workbud.com>
+ * @param error The thrown or returned value.
+ * @param context The request and the application's problem options.
+ */
+export declare const toProblem: (error: unknown, context: ProblemContext) => ProblemDetails;
+/**
+ * Builds the `application/problem+json` response of a problem.
+ * @author Axel Nana <axel.nana@workbud.com>
+ * @param problem The problem details.
+ * @param headers Extra headers, such as `Retry-After`.
+ */
+export declare const problemResponse: (problem: ProblemDetails, headers?: Record<string, string>) => Response;
+/**
+ * The OpenAPI schema of problem details, referenced by the default error responses of each route.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export declare const ProblemDetailsSchema: import("typebox").TObject<{
+    type: import("typebox").TString;
+    title: import("typebox").TString;
+    status: import("typebox").TInteger;
+    code: import("typebox").TString;
+    detail: import("typebox").TOptional<import("typebox").TString>;
+    instance: import("typebox").TOptional<import("typebox").TString>;
+    requestId: import("typebox").TOptional<import("typebox").TString>;
+    retryAfter: import("typebox").TOptional<import("typebox").TInteger>;
+    errors: import("typebox").TOptional<import("typebox").TArray<import("typebox").TObject<{
+        pointer: import("typebox").TString;
+        message: import("typebox").TString;
+        code: import("typebox").TOptional<import("typebox").TString>;
+    }>>>;
+}>;
+export {};