@tempoxyz/id 0.0.0-stage → 0.0.0

package/dist/internal/Env.d.ts

@@ -0,0 +1,57 @@
+/**
+ * The Hono environment that Tempo ID's middleware and route apps share: the page renderer that the
+ * root app falls back to, and the variables that `Timing.middleware` and `RequestId.middleware()`
+ * set on each request.
+ * @module
+ */
+import type { Context } from 'hono';
+import type * as Auth from './Auth.js';
+import type * as Limits from './Limits.js';
+import type * as RateLimit from './RateLimit.js';
+import type * as RequestId from './RequestId.js';
+import type * as TestInbox from './TestInbox.js';
+import type * as Timing from './Timing.js';
+import type * as Wallet from './Wallet.js';
+/** The bindings and variables of a request that Tempo ID's middleware serves. */
+export type Env = {
+    /**
+     * The bindings that the root app reads: the page renderer, each rate limit by its name,
+     * wallet.tempo's passkey lookup, and a preview's test inbox.
+     */
+    Bindings: {
+        /**
+         * Renders the request's page through TanStack Start, or runs one of its server functions, with
+         * the request's context. A path that no route serves renders the not-found page.
+         */
+        pages: (c: Context<Env>) => Promise<Response>;
+        /**
+         * The test inbox, which receives the sign-in codes of addresses under `TEST_EMAIL_DOMAIN`. Only a
+         * preview binds it. Absent, every code is emailed.
+         */
+        TEST_INBOX?: TestInbox.Service | undefined;
+        /**
+         * wallet.tempo's `Credentials` entrypoint, which links its passkeys at their first sign-in.
+         * Absent, only passkeys that Tempo ID stores sign in.
+         */
+        WALLET?: Wallet.Service | undefined;
+    } & Record<Limits.Limit, RateLimit.Limiter>;
+    /** The values that middleware sets on `c.var` for each request. */
+    Variables: Variables;
+};
+/** The values that middleware sets on `c.var` for each request. */
+export type Variables = {
+    /**
+     * Whether the request already chose the app's account, as `POST /v1/authorize` does before its
+     * in-process authorization. The account step then reads no accounts again. Absent elsewhere.
+     */
+    accountChosen?: boolean | undefined;
+    /** The request's Better Auth instance, which `Auth.middleware` in `src/api/lib/Auth.ts` sets. */
+    auth: Auth.Instance;
+    /** The codes of the response's OAuth error body, which `RequestId.middleware()` reads. */
+    refusal: RequestId.Refusal | undefined;
+    /** The request ID, which `RequestId.middleware()` assigns. */
+    requestId: string;
+    /** The request's timings, which `Timing.measure` appends to. */
+    timing: Timing.Timing;
+};
+//# sourceMappingURL=Env.d.ts.map

package/dist/internal/Env.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Env.d.ts","sourceRoot":"","sources":["../../src/internal/Env.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AACnC,OAAO,KAAK,KAAK,IAAI,MAAM,WAAW,CAAA;AACtC,OAAO,KAAK,KAAK,MAAM,MAAM,aAAa,CAAA;AAC1C,OAAO,KAAK,KAAK,SAAS,MAAM,gBAAgB,CAAA;AAChD,OAAO,KAAK,KAAK,SAAS,MAAM,gBAAgB,CAAA;AAChD,OAAO,KAAK,KAAK,SAAS,MAAM,gBAAgB,CAAA;AAChD,OAAO,KAAK,KAAK,MAAM,MAAM,aAAa,CAAA;AAC1C,OAAO,KAAK,KAAK,MAAM,MAAM,aAAa,CAAA;AAE1C,iFAAiF;AACjF,MAAM,MAAM,GAAG,GAAG;IAChB;;;OAGG;IACH,QAAQ,EAAE;QACR;;;WAGG;QACH,KAAK,EAAE,CAAC,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAA;QAC7C;;;WAGG;QACH,UAAU,CAAC,EAAE,SAAS,CAAC,OAAO,GAAG,SAAS,CAAA;QAC1C;;;WAGG;QACH,MAAM,CAAC,EAAE,MAAM,CAAC,OAAO,GAAG,SAAS,CAAA;KACpC,GAAG,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,SAAS,CAAC,OAAO,CAAC,CAAA;IAC3C,mEAAmE;IACnE,SAAS,EAAE,SAAS,CAAA;CACrB,CAAA;AAED,mEAAmE;AACnE,MAAM,MAAM,SAAS,GAAG;IACtB;;;OAGG;IACH,aAAa,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;IACnC,iGAAiG;IACjG,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAA;IACnB,0FAA0F;IAC1F,OAAO,EAAE,SAAS,CAAC,OAAO,GAAG,SAAS,CAAA;IACtC,8DAA8D;IAC9D,SAAS,EAAE,MAAM,CAAA;IACjB,gEAAgE;IAChE,MAAM,EAAE,MAAM,CAAC,MAAM,CAAA;CACtB,CAAA"}

package/dist/internal/Env.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Env.js.map

package/dist/internal/Env.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Env.js","sourceRoot":"","sources":["../../src/internal/Env.ts"],"names":[],"mappings":""}

package/dist/internal/ErrorResponse.d.ts

@@ -0,0 +1,609 @@
+/**
+ * OAuth error responses ([RFC 6749 §5.2](https://www.rfc-editor.org/rfc/rfc6749#section-5.2)):
+ * `error`, `error_description`, and `error_uri`, with extension members apps can branch on. OAuth
+ * clients ignore members they do not recognize. Every refusal names a `reason`, and each reason
+ * has exactly one `error` and one HTTP status, so a reason fully determines the response.
+ * @module
+ */
+import type { Context, TypedResponse } from 'hono';
+import { HTTPException } from 'hono/http-exception';
+import type { ContentfulStatusCode } from 'hono/utils/http-status';
+import type { JSONParsed } from 'hono/utils/types';
+import * as z from 'zod';
+/**
+ * Every refusal Tempo ID returns, by `reason`: its OAuth `error` code, its HTTP status, and what it
+ * means. `docs/errors.md` explains each one.
+ */
+export declare const reasons: {
+    readonly already_decided: {
+        readonly description: 'The user code was already approved or denied.';
+        readonly error: 'invalid_request';
+        readonly status: 409;
+    };
+    readonly approval_pending: {
+        readonly description: 'The user has not decided the device code yet.';
+        readonly error: 'authorization_pending';
+        readonly status: 400;
+    };
+    readonly authorization_expired: {
+        readonly description: "The app's authorization request that sign-in or the approval page continues is forged or expired.";
+        readonly error: 'invalid_request';
+        readonly status: 400;
+    };
+    readonly body_too_large: {
+        readonly description: 'The request body exceeds 64 KiB.';
+        readonly error: 'invalid_request';
+        readonly status: 413;
+    };
+    readonly challenge_not_permitted: {
+        readonly description: 'A request carries a challenge, and its app lacks the `tempo-id:sign` scope.';
+        readonly error: 'unauthorized_client';
+        readonly status: 403;
+    };
+    readonly cross_site_request: {
+        readonly description: 'A form or body-less write came from another site.';
+        readonly error: 'access_denied';
+        readonly status: 403;
+    };
+    readonly device_code_expired: {
+        readonly description: 'The device code is unknown, expired, or already redeemed.';
+        readonly error: 'expired_token';
+        readonly status: 400;
+    };
+    readonly duplicate_limit: {
+        readonly description: 'Two limits name the same token.';
+        readonly error: 'invalid_authorization_details';
+        readonly status: 400;
+    };
+    readonly duplicate_scope: {
+        readonly description: 'Two scopes name the same call on one token.';
+        readonly error: 'invalid_authorization_details';
+        readonly status: 400;
+    };
+    readonly empty_limits: {
+        readonly description: '`limits` is an empty list.';
+        readonly error: 'invalid_authorization_details';
+        readonly status: 400;
+    };
+    readonly empty_scopes: {
+        readonly description: '`scopes` is an empty list.';
+        readonly error: 'invalid_authorization_details';
+        readonly status: 400;
+    };
+    readonly expiry_exceeds_maximum: {
+        readonly description: 'A headless key lasts longer than a year.';
+        readonly error: 'invalid_authorization_details';
+        readonly status: 403;
+    };
+    readonly expiry_passed: {
+        readonly description: 'The key expiry has passed.';
+        readonly error: 'invalid_authorization_details';
+        readonly status: 400;
+    };
+    readonly foreign_account: {
+        readonly description: "The request names a Tempo Account that is not the user's in the app's realms.";
+        readonly error: 'access_denied';
+        readonly status: 403;
+    };
+    readonly invalid_chain: {
+        readonly description: 'The key chain ID is 0.';
+        readonly error: 'invalid_authorization_details';
+        readonly status: 400;
+    };
+    readonly invalid_code: {
+        readonly description: 'The emailed code is wrong or expired.';
+        readonly error: 'invalid_grant';
+        readonly status: 401;
+    };
+    readonly invalid_expiry: {
+        readonly description: 'The key expiry is 0, which never expires.';
+        readonly error: 'invalid_authorization_details';
+        readonly status: 400;
+    };
+    readonly invalid_field: {
+        readonly description: 'A field is missing or malformed.';
+        readonly error: 'invalid_request';
+        readonly status: 400;
+    };
+    readonly invalid_id_token_hint: {
+        readonly description: 'The ID token hint is not an ID token that Tempo ID signed for the app.';
+        readonly error: 'invalid_request';
+        readonly status: 400;
+    };
+    readonly invalid_origin: {
+        readonly description: 'A headless request came from an origin its redirect URI does not allow.';
+        readonly error: 'unauthorized_client';
+        readonly status: 403;
+    };
+    readonly invalid_period: {
+        readonly description: "A limit's `period` is not a whole number of seconds.";
+        readonly error: 'invalid_authorization_details';
+        readonly status: 400;
+    };
+    readonly invalid_public_key: {
+        readonly description: 'The key public key is not a valid point.';
+        readonly error: 'invalid_authorization_details';
+        readonly status: 400;
+    };
+    readonly invalid_recipients: {
+        readonly description: "A scope's `recipients` names the zero address, or one address twice.";
+        readonly error: 'invalid_authorization_details';
+        readonly status: 400;
+    };
+    readonly limit_exceeds_maximum: {
+        readonly description: 'A headless key limit exceeds the token’s ceiling.';
+        readonly error: 'invalid_authorization_details';
+        readonly status: 403;
+    };
+    readonly logout_not_permitted: {
+        readonly description: 'The app that the ID token hint names may not end the session at the end-session endpoint.';
+        readonly error: 'unauthorized_client';
+        readonly status: 403;
+    };
+    readonly malformed_body: {
+        readonly description: 'The request body is not valid JSON.';
+        readonly error: 'invalid_request';
+        readonly status: 400;
+    };
+    readonly missing_key: {
+        readonly description: 'The key authorization names no key.';
+        readonly error: 'invalid_authorization_details';
+        readonly status: 400;
+    };
+    readonly missing_recipients: {
+        readonly description: 'An `approve` scope names no spenders.';
+        readonly error: 'invalid_authorization_details';
+        readonly status: 400;
+    };
+    readonly passkey_link_expired: {
+        readonly description: "The email step's link to a wallet.tempo passkey expired, or the browser holds no link for it.";
+        readonly error: 'invalid_request';
+        readonly status: 400;
+    };
+    readonly passkey_not_permitted: {
+        readonly description: 'A passkey sign-in names an app, or reaches a realm, that holds no passkeys for Tempo ID.';
+        readonly error: 'unauthorized_client';
+        readonly status: 403;
+    };
+    readonly polling_too_fast: {
+        readonly description: 'The device polled before its interval passed.';
+        readonly error: 'slow_down';
+        readonly status: 400;
+    };
+    readonly post_logout_redirect_not_permitted: {
+        readonly description: 'The post-logout redirect URI is not one of the post-logout redirect URIs the app registered.';
+        readonly error: 'invalid_request';
+        readonly status: 400;
+    };
+    readonly rate_limited: {
+        readonly description: 'Tempo ID, or a service it depends on, is rate limiting the request.';
+        readonly error: 'temporarily_unavailable';
+        readonly status: 429;
+    };
+    readonly rejected: {
+        readonly description: 'The issuer refused the authorization request.';
+        readonly error: 'invalid_request';
+        readonly status: 400;
+    };
+    readonly request_denied: {
+        readonly description: 'The user denied the device code.';
+        readonly error: 'access_denied';
+        readonly status: 400;
+    };
+    readonly return_to_not_permitted: {
+        readonly description: "The page that a provider sign-in returns to is on neither Tempo ID's origin nor the app's.";
+        readonly error: 'invalid_request';
+        readonly status: 400;
+    };
+    readonly scope_without_limit: {
+        readonly description: 'A scope calls a token no limit names.';
+        readonly error: 'invalid_authorization_details';
+        readonly status: 400;
+    };
+    readonly session_changed: {
+        readonly description: 'The signed-in session differs from the one that the approval page showed.';
+        readonly error: 'invalid_request';
+        readonly status: 409;
+    };
+    readonly session_required: {
+        readonly description: 'The request needs a signed-in session.';
+        readonly error: 'login_required';
+        readonly status: 401;
+    };
+    readonly unexpected: {
+        readonly description: 'An unexpected failure.';
+        readonly error: 'server_error';
+        readonly status: 500;
+    };
+    readonly unknown_code: {
+        readonly description: 'The user code is wrong or expired.';
+        readonly error: 'invalid_request';
+        readonly status: 404;
+    };
+    readonly unknown_endpoint: {
+        readonly description: 'No API endpoint matches this method and path.';
+        readonly error: 'invalid_request';
+        readonly status: 404;
+    };
+    readonly unknown_provider: {
+        readonly description: 'The sign-in names a provider that Tempo ID does not offer.';
+        readonly error: 'invalid_request';
+        readonly status: 404;
+    };
+    readonly unsupported_call: {
+        readonly description: 'A scope calls a function a key may not call.';
+        readonly error: 'invalid_authorization_details';
+        readonly status: 400;
+    };
+    readonly unsupported_token: {
+        readonly description: 'A limit names a token that is not supported on the chain.';
+        readonly error: 'invalid_authorization_details';
+        readonly status: 400;
+    };
+    readonly upstream_unavailable: {
+        readonly description: 'A service Tempo ID depends on failed or did not respond.';
+        readonly error: 'temporarily_unavailable';
+        readonly status: 503;
+    };
+    readonly webauthn_rejected: {
+        readonly description: 'A passkey ceremony failed: its challenge is unknown, spent, or expired, or its response does not verify.';
+        readonly error: 'access_denied';
+        readonly status: 401;
+    };
+    readonly webauthn_required: {
+        readonly description: 'A request without a page names a Tempo Account whose passkey signs only on a Tempo ID page.';
+        readonly error: 'interaction_required';
+        readonly status: 403;
+    };
+};
+/** Each refusal's stable name. */
+export type Reason = keyof typeof reasons;
+/** The OAuth error code of a refusal. */
+export type Code = (typeof reasons)[Reason]['error'];
+/** The HTTP status of `reason`. */
+export type Status<reason extends Reason = Reason> = (typeof reasons)[reason]['status'];
+/** An OAuth error response for `reason`, as its schema reads it. */
+export type ErrorResponse<reason extends Reason = Reason> = reason extends Reason ? Omit<z.output<typeof schema.base>, 'error' | 'reason'> & {
+    /** The OAuth error code, which `reason` determines. */
+    error: (typeof reasons)[reason]['error'];
+    /** A stable name for the refusal, for apps to branch on. */
+    reason: reason;
+} : never;
+/** The JSON response `json` returns for `reason`. One per reason, so each keeps its status. */
+export type Json<reason extends Reason> = reason extends Reason ? Response & TypedResponse<JSONParsed<ErrorResponse<reason>>, Status<reason>, 'json'> : never;
+/** A refusal's class, which `fn.errors` lists. Its static `reason` names the refusal. */
+export type Class = (abstract new (...args: never[]) => ResponseError) & {
+    /** The reason of every refusal the class constructs. */
+    readonly reason: Reason;
+};
+/** An instance of one of the classes in `errors`: the return type of a function returning refusals. */
+export type Instance<errors extends readonly Class[]> = InstanceType<errors[number]>;
+/**
+ * A refusal, which a function returns or throws. `json` responds with a returned one, and `handle`
+ * with a thrown one. Each refusal is a subclass that {@link define} makes, so its reason is written
+ * once.
+ */
+export declare class ResponseError<reason extends Reason = Reason> extends HTTPException {
+    readonly name: string;
+    /** The error response the refusal sends. */
+    readonly response: ErrorResponse<reason>;
+    constructor(response: ErrorResponse<reason>);
+}
+/**
+ * Returns the base class of `reason`'s refusals, whose static `reason` is `reason`. The module that
+ * returns or throws a refusal declares it as a subclass, such as
+ * `class InvalidCodeError extends ErrorResponse.define('invalid_code') {}`, and lists the class in
+ * its `fn.errors`.
+ */
+export declare function define<const reason extends Reason>(reason: reason): {
+    new (options: define.Options): {
+        message: string;
+        stack?: string;
+        cause?: unknown;
+        readonly res?: Response;
+        readonly status: ContentfulStatusCode;
+        getResponse(): Response;
+        readonly name: string;
+        /** The error response the refusal sends. */
+        readonly response: ErrorResponse<reason>;
+    };
+    readonly reason: reason;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+export declare namespace define {
+    type Options = Omit<from.Value<Reason>, 'reason'>;
+}
+declare const CrossSiteRequestError_base: {
+    new (options: define.Options): {
+        message: string;
+        stack?: string;
+        cause?: unknown;
+        readonly res?: Response;
+        readonly status: ContentfulStatusCode;
+        getResponse(): Response;
+        readonly name: string;
+        /** The error response the refusal sends. */
+        readonly response: Omit<{
+            error: string;
+            error_description: string;
+            error_uri: string;
+            field?: string | undefined;
+            meta?: Readonly<Record<string, string | number>> | undefined;
+            reason: string;
+            request_id?: string | undefined;
+        }, "error" | "reason"> & {
+            /** The OAuth error code, which `reason` determines. */
+            error: "access_denied";
+            /** A stable name for the refusal, for apps to branch on. */
+            reason: "cross_site_request";
+        };
+    };
+    readonly reason: "cross_site_request";
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+/**
+ * A form or body-less write came from another site, which `csrf()` refuses, or a cross-site read of
+ * `GET /v1/account`.
+ */
+export declare class CrossSiteRequestError extends CrossSiteRequestError_base {
+    readonly name = "ErrorResponse.CrossSiteRequestError";
+    constructor();
+}
+declare const MalformedBodyError_base: {
+    new (options: define.Options): {
+        message: string;
+        stack?: string;
+        cause?: unknown;
+        readonly res?: Response;
+        readonly status: ContentfulStatusCode;
+        getResponse(): Response;
+        readonly name: string;
+        /** The error response the refusal sends. */
+        readonly response: Omit<{
+            error: string;
+            error_description: string;
+            error_uri: string;
+            field?: string | undefined;
+            meta?: Readonly<Record<string, string | number>> | undefined;
+            reason: string;
+            request_id?: string | undefined;
+        }, "error" | "reason"> & {
+            /** The OAuth error code, which `reason` determines. */
+            error: "invalid_request";
+            /** A stable name for the refusal, for apps to branch on. */
+            reason: "malformed_body";
+        };
+    };
+    readonly reason: "malformed_body";
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+/** The body is not valid JSON, which Hono's body validator refuses. */
+export declare class MalformedBodyError extends MalformedBodyError_base {
+    readonly name = "ErrorResponse.MalformedBodyError";
+    constructor();
+}
+declare const RateLimitedError_base: {
+    new (options: define.Options): {
+        message: string;
+        stack?: string;
+        cause?: unknown;
+        readonly res?: Response;
+        readonly status: ContentfulStatusCode;
+        getResponse(): Response;
+        readonly name: string;
+        /** The error response the refusal sends. */
+        readonly response: Omit<{
+            error: string;
+            error_description: string;
+            error_uri: string;
+            field?: string | undefined;
+            meta?: Readonly<Record<string, string | number>> | undefined;
+            reason: string;
+            request_id?: string | undefined;
+        }, "error" | "reason"> & {
+            /** The OAuth error code, which `reason` determines. */
+            error: "temporarily_unavailable";
+            /** A stable name for the refusal, for apps to branch on. */
+            reason: "rate_limited";
+        };
+    };
+    readonly reason: "rate_limited";
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+/** A service Tempo ID depends on, such as Privy, is rate limiting it. */
+export declare class RateLimitedError extends RateLimitedError_base {
+    readonly name = "ErrorResponse.RateLimitedError";
+    /** The wait in seconds that the service requested, which `handle` sends as `Retry-After`. */
+    readonly retryAfter: number | undefined;
+    constructor(options?: RateLimitedError.Options);
+}
+export declare namespace RateLimitedError {
+    type Options = {
+        /** The wait in seconds that the service requested. */
+        retryAfter?: number | undefined;
+    };
+}
+declare const UnexpectedError_base: {
+    new (options: define.Options): {
+        message: string;
+        stack?: string;
+        cause?: unknown;
+        readonly res?: Response;
+        readonly status: ContentfulStatusCode;
+        getResponse(): Response;
+        readonly name: string;
+        /** The error response the refusal sends. */
+        readonly response: Omit<{
+            error: string;
+            error_description: string;
+            error_uri: string;
+            field?: string | undefined;
+            meta?: Readonly<Record<string, string | number>> | undefined;
+            reason: string;
+            request_id?: string | undefined;
+        }, "error" | "reason"> & {
+            /** The OAuth error code, which `reason` determines. */
+            error: "server_error";
+            /** A stable name for the refusal, for apps to branch on. */
+            reason: "unexpected";
+        };
+    };
+    readonly reason: "unexpected";
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+/** An unexpected failure, which `handle` logs. */
+export declare class UnexpectedError extends UnexpectedError_base {
+    readonly name = "ErrorResponse.UnexpectedError";
+    constructor();
+}
+declare const UnknownEndpointError_base: {
+    new (options: define.Options): {
+        message: string;
+        stack?: string;
+        cause?: unknown;
+        readonly res?: Response;
+        readonly status: ContentfulStatusCode;
+        getResponse(): Response;
+        readonly name: string;
+        /** The error response the refusal sends. */
+        readonly response: Omit<{
+            error: string;
+            error_description: string;
+            error_uri: string;
+            field?: string | undefined;
+            meta?: Readonly<Record<string, string | number>> | undefined;
+            reason: string;
+            request_id?: string | undefined;
+        }, "error" | "reason"> & {
+            /** The OAuth error code, which `reason` determines. */
+            error: "invalid_request";
+            /** A stable name for the refusal, for apps to branch on. */
+            reason: "unknown_endpoint";
+        };
+    };
+    readonly reason: "unknown_endpoint";
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+/** No API route matches the method and path. */
+export declare class UnknownEndpointError extends UnknownEndpointError_base {
+    readonly name = "ErrorResponse.UnknownEndpointError";
+    constructor();
+}
+declare const UpstreamUnavailableError_base: {
+    new (options: define.Options): {
+        message: string;
+        stack?: string;
+        cause?: unknown;
+        readonly res?: Response;
+        readonly status: ContentfulStatusCode;
+        getResponse(): Response;
+        readonly name: string;
+        /** The error response the refusal sends. */
+        readonly response: Omit<{
+            error: string;
+            error_description: string;
+            error_uri: string;
+            field?: string | undefined;
+            meta?: Readonly<Record<string, string | number>> | undefined;
+            reason: string;
+            request_id?: string | undefined;
+        }, "error" | "reason"> & {
+            /** The OAuth error code, which `reason` determines. */
+            error: "temporarily_unavailable";
+            /** A stable name for the refusal, for apps to branch on. */
+            reason: "upstream_unavailable";
+        };
+    };
+    readonly reason: "upstream_unavailable";
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+/** A service Tempo ID depends on, such as Privy, failed or did not respond. */
+export declare class UpstreamUnavailableError extends UpstreamUnavailableError_base {
+    readonly name = "ErrorResponse.UpstreamUnavailableError";
+    constructor();
+}
+/** Zod schemas for every error response, which the OpenAPI document reads. */
+export declare namespace schema {
+    /** The members every error response has. */
+    const base: z.ZodObject<{
+        error: z.ZodString;
+        error_description: z.ZodString;
+        error_uri: z.ZodURL;
+        field: z.ZodOptional<z.ZodString>;
+        meta: z.ZodOptional<z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>>>;
+        reason: z.ZodString;
+        request_id: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    /** The schema of `reason`'s error response. */
+    function of<const reason extends Reason>(reason: reason): z.ZodType<ErrorResponse<reason>>;
+}
+/**
+ * Instantiates an {@link ErrorResponse}, filling `error` from `reason`'s definition and
+ * `error_uri` with `reason`'s section of the errors page.
+ */
+export declare function from<const reason extends Reason>(value: from.Value<reason>): ErrorResponse<reason>;
+export declare namespace from {
+    type Value<reason extends Reason> = {
+        /** What went wrong and how to fix it, for people. */
+        error_description: string;
+        /** The request field at fault, as a dotted path. */
+        field?: string | undefined;
+        /** The values the refusal compared. Base units are decimal strings. */
+        meta?: Readonly<Record<string, number | string>> | undefined;
+        /** The refusal, which determines `error` and the status. */
+        reason: reason;
+    };
+}
+/**
+ * Returns the refusal for an upstream service's failure, from the error its SDK threw or the
+ * response it sent. The refusal is `rate_limited` for a 429, and `upstream_unavailable` for a 408,
+ * a 5xx, a timeout, or a request that received no response. Returns `undefined` for anything else,
+ * such as an error Tempo ID throws itself.
+ */
+export declare function fromUpstream(failure: Error | Response): Instance<typeof fromUpstream.errors> | undefined;
+export declare namespace fromUpstream {
+    /** The refusals `fromUpstream` returns for an upstream service's failure. */
+    const errors: readonly [typeof RateLimitedError, typeof UpstreamUnavailableError];
+}
+/**
+ * Maps any error a handler or middleware throws to its documented response:
+ *
+ * - A {@link ResponseError} maps to its own response.
+ * - Hono's malformed body refusal maps to `malformed_body`.
+ * - The CSRF check's refusal maps to `cross_site_request`.
+ * - An upstream service's failure maps to `rate_limited` or `upstream_unavailable`, and logs a
+ *   warning.
+ * - Anything else maps to `unexpected`, and logs the error.
+ */
+export declare function handle(error: Error, c: Context): Response & TypedResponse<{
+    error: any;
+    reason: any;
+    error_description: string;
+    error_uri: string;
+    field?: string | undefined;
+    meta?: {
+        readonly [x: string]: string | number;
+    } | undefined;
+    request_id?: string | undefined;
+}, any, "json">;
+/**
+ * Returns the response for `error`, at the status its `reason` determines. A `rate_limited` refusal
+ * that carries the service's wait also sends it as `Retry-After`.
+ */
+export declare function json<const reason extends Reason>(c: Context, error: ResponseError<reason>): Json<reason>;
+export {};
+//# sourceMappingURL=ErrorResponse.d.ts.map