@tempoxyz/id 0.0.0-stage → 0.0.0

package/dist/internal/KeyAuthorization.d.ts

@@ -0,0 +1,1456 @@
+/**
+ * Access keys (TIP-1011) on a user's Tempo Account, for keys that apps hold. A request takes the
+ * shape of the Accounts SDK's `wallet_connect` key authorization capability. The user approves it on
+ * a page, or it must fit the headless ceiling, and the account's owner signs it. An app that holds
+ * the `tempo-id:sign` scope may send a challenge. Tempo ID binds the challenge as the key's witness
+ * (TIP-1053), so the owner's one signature covers both.
+ * @module
+ */
+import { Address, Hex } from 'ox';
+import { KeyAuthorization } from 'ox/tempo';
+import { Account } from 'viem/tempo';
+import { z } from 'zod';
+import * as Apps from './Apps.js';
+import * as ErrorResponse from './ErrorResponse.js';
+import type * as Passkey from './Passkey.js';
+declare const ChallengeNotPermittedError_base: {
+    new (options: ErrorResponse.define.Options): {
+        message: string;
+        stack?: string;
+        cause?: unknown;
+        readonly res?: Response;
+        readonly status: import("hono/utils/http-status").ContentfulStatusCode;
+        getResponse(): Response;
+        readonly name: string;
+        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"> & {
+            error: "unauthorized_client";
+            reason: "challenge_not_permitted";
+        };
+    };
+    readonly reason: "challenge_not_permitted";
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+/** The request carries a challenge, which its app may not bind. */
+export declare class ChallengeNotPermittedError extends ChallengeNotPermittedError_base {
+    readonly name = "KeyAuthorization.ChallengeNotPermittedError";
+    constructor(options: ChallengeNotPermittedError.Options);
+}
+export declare namespace ChallengeNotPermittedError {
+    type Options = {
+        /** The app's client ID. */
+        clientId: string;
+    };
+}
+declare const DuplicateLimitError_base: {
+    new (options: ErrorResponse.define.Options): {
+        message: string;
+        stack?: string;
+        cause?: unknown;
+        readonly res?: Response;
+        readonly status: import("hono/utils/http-status").ContentfulStatusCode;
+        getResponse(): Response;
+        readonly name: string;
+        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"> & {
+            error: "invalid_authorization_details";
+            reason: "duplicate_limit";
+        };
+    };
+    readonly reason: "duplicate_limit";
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+/** Two limits name the same token. */
+export declare class DuplicateLimitError extends DuplicateLimitError_base {
+    readonly name = "KeyAuthorization.DuplicateLimitError";
+}
+declare const DuplicateScopeError_base: {
+    new (options: ErrorResponse.define.Options): {
+        message: string;
+        stack?: string;
+        cause?: unknown;
+        readonly res?: Response;
+        readonly status: import("hono/utils/http-status").ContentfulStatusCode;
+        getResponse(): Response;
+        readonly name: string;
+        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"> & {
+            error: "invalid_authorization_details";
+            reason: "duplicate_scope";
+        };
+    };
+    readonly reason: "duplicate_scope";
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+/** Two scopes name the same call on one token. */
+export declare class DuplicateScopeError extends DuplicateScopeError_base {
+    readonly name = "KeyAuthorization.DuplicateScopeError";
+}
+declare const EmptyLimitsError_base: {
+    new (options: ErrorResponse.define.Options): {
+        message: string;
+        stack?: string;
+        cause?: unknown;
+        readonly res?: Response;
+        readonly status: import("hono/utils/http-status").ContentfulStatusCode;
+        getResponse(): Response;
+        readonly name: string;
+        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"> & {
+            error: "invalid_authorization_details";
+            reason: "empty_limits";
+        };
+    };
+    readonly reason: "empty_limits";
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+/** `limits` is an empty list. */
+export declare class EmptyLimitsError extends EmptyLimitsError_base {
+    readonly name = "KeyAuthorization.EmptyLimitsError";
+}
+declare const EmptyScopesError_base: {
+    new (options: ErrorResponse.define.Options): {
+        message: string;
+        stack?: string;
+        cause?: unknown;
+        readonly res?: Response;
+        readonly status: import("hono/utils/http-status").ContentfulStatusCode;
+        getResponse(): Response;
+        readonly name: string;
+        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"> & {
+            error: "invalid_authorization_details";
+            reason: "empty_scopes";
+        };
+    };
+    readonly reason: "empty_scopes";
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+/** `scopes` is an empty list. */
+export declare class EmptyScopesError extends EmptyScopesError_base {
+    readonly name = "KeyAuthorization.EmptyScopesError";
+}
+declare const ExpiryExceedsMaximumError_base: {
+    new (options: ErrorResponse.define.Options): {
+        message: string;
+        stack?: string;
+        cause?: unknown;
+        readonly res?: Response;
+        readonly status: import("hono/utils/http-status").ContentfulStatusCode;
+        getResponse(): Response;
+        readonly name: string;
+        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"> & {
+            error: "invalid_authorization_details";
+            reason: "expiry_exceeds_maximum";
+        };
+    };
+    readonly reason: "expiry_exceeds_maximum";
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+/** A headless key lasts longer than a year. */
+export declare class ExpiryExceedsMaximumError extends ExpiryExceedsMaximumError_base {
+    readonly name = "KeyAuthorization.ExpiryExceedsMaximumError";
+}
+declare const ExpiryPassedError_base: {
+    new (options: ErrorResponse.define.Options): {
+        message: string;
+        stack?: string;
+        cause?: unknown;
+        readonly res?: Response;
+        readonly status: import("hono/utils/http-status").ContentfulStatusCode;
+        getResponse(): Response;
+        readonly name: string;
+        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"> & {
+            error: "invalid_authorization_details";
+            reason: "expiry_passed";
+        };
+    };
+    readonly reason: "expiry_passed";
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+/** The key expiry is in the past. */
+export declare class ExpiryPassedError extends ExpiryPassedError_base {
+    readonly name = "KeyAuthorization.ExpiryPassedError";
+}
+declare const InvalidChainError_base: {
+    new (options: ErrorResponse.define.Options): {
+        message: string;
+        stack?: string;
+        cause?: unknown;
+        readonly res?: Response;
+        readonly status: import("hono/utils/http-status").ContentfulStatusCode;
+        getResponse(): Response;
+        readonly name: string;
+        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"> & {
+            error: "invalid_authorization_details";
+            reason: "invalid_chain";
+        };
+    };
+    readonly reason: "invalid_chain";
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+/** The key chain ID is 0. */
+export declare class InvalidChainError extends InvalidChainError_base {
+    readonly name = "KeyAuthorization.InvalidChainError";
+}
+declare const InvalidExpiryError_base: {
+    new (options: ErrorResponse.define.Options): {
+        message: string;
+        stack?: string;
+        cause?: unknown;
+        readonly res?: Response;
+        readonly status: import("hono/utils/http-status").ContentfulStatusCode;
+        getResponse(): Response;
+        readonly name: string;
+        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"> & {
+            error: "invalid_authorization_details";
+            reason: "invalid_expiry";
+        };
+    };
+    readonly reason: "invalid_expiry";
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+/** The key expiry is 0, which never expires. */
+export declare class InvalidExpiryError extends InvalidExpiryError_base {
+    readonly name = "KeyAuthorization.InvalidExpiryError";
+}
+declare const InvalidPeriodError_base: {
+    new (options: ErrorResponse.define.Options): {
+        message: string;
+        stack?: string;
+        cause?: unknown;
+        readonly res?: Response;
+        readonly status: import("hono/utils/http-status").ContentfulStatusCode;
+        getResponse(): Response;
+        readonly name: string;
+        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"> & {
+            error: "invalid_authorization_details";
+            reason: "invalid_period";
+        };
+    };
+    readonly reason: "invalid_period";
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+/** A limit's `period` is not a whole number of seconds. */
+export declare class InvalidPeriodError extends InvalidPeriodError_base {
+    readonly name = "KeyAuthorization.InvalidPeriodError";
+}
+declare const InvalidPublicKeyError_base: {
+    new (options: ErrorResponse.define.Options): {
+        message: string;
+        stack?: string;
+        cause?: unknown;
+        readonly res?: Response;
+        readonly status: import("hono/utils/http-status").ContentfulStatusCode;
+        getResponse(): Response;
+        readonly name: string;
+        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"> & {
+            error: "invalid_authorization_details";
+            reason: "invalid_public_key";
+        };
+    };
+    readonly reason: "invalid_public_key";
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+/** The key public key is not a valid point. */
+export declare class InvalidPublicKeyError extends InvalidPublicKeyError_base {
+    readonly name = "KeyAuthorization.InvalidPublicKeyError";
+}
+declare const InvalidRecipientsError_base: {
+    new (options: ErrorResponse.define.Options): {
+        message: string;
+        stack?: string;
+        cause?: unknown;
+        readonly res?: Response;
+        readonly status: import("hono/utils/http-status").ContentfulStatusCode;
+        getResponse(): Response;
+        readonly name: string;
+        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"> & {
+            error: "invalid_authorization_details";
+            reason: "invalid_recipients";
+        };
+    };
+    readonly reason: "invalid_recipients";
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+/** A scope's `recipients` names the zero address, or one address twice. */
+export declare class InvalidRecipientsError extends InvalidRecipientsError_base {
+    readonly name = "KeyAuthorization.InvalidRecipientsError";
+}
+declare const LimitExceedsMaximumError_base: {
+    new (options: ErrorResponse.define.Options): {
+        message: string;
+        stack?: string;
+        cause?: unknown;
+        readonly res?: Response;
+        readonly status: import("hono/utils/http-status").ContentfulStatusCode;
+        getResponse(): Response;
+        readonly name: string;
+        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"> & {
+            error: "invalid_authorization_details";
+            reason: "limit_exceeds_maximum";
+        };
+    };
+    readonly reason: "limit_exceeds_maximum";
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+/** A headless key limit exceeds the token’s ceiling. */
+export declare class LimitExceedsMaximumError extends LimitExceedsMaximumError_base {
+    readonly name = "KeyAuthorization.LimitExceedsMaximumError";
+}
+declare const MissingKeyError_base: {
+    new (options: ErrorResponse.define.Options): {
+        message: string;
+        stack?: string;
+        cause?: unknown;
+        readonly res?: Response;
+        readonly status: import("hono/utils/http-status").ContentfulStatusCode;
+        getResponse(): Response;
+        readonly name: string;
+        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"> & {
+            error: "invalid_authorization_details";
+            reason: "missing_key";
+        };
+    };
+    readonly reason: "missing_key";
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+/** The key authorization names no key. */
+export declare class MissingKeyError extends MissingKeyError_base {
+    readonly name = "KeyAuthorization.MissingKeyError";
+}
+declare const MissingRecipientsError_base: {
+    new (options: ErrorResponse.define.Options): {
+        message: string;
+        stack?: string;
+        cause?: unknown;
+        readonly res?: Response;
+        readonly status: import("hono/utils/http-status").ContentfulStatusCode;
+        getResponse(): Response;
+        readonly name: string;
+        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"> & {
+            error: "invalid_authorization_details";
+            reason: "missing_recipients";
+        };
+    };
+    readonly reason: "missing_recipients";
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+/** An `approve` scope names no spenders. */
+export declare class MissingRecipientsError extends MissingRecipientsError_base {
+    readonly name = "KeyAuthorization.MissingRecipientsError";
+}
+declare const ScopeWithoutLimitError_base: {
+    new (options: ErrorResponse.define.Options): {
+        message: string;
+        stack?: string;
+        cause?: unknown;
+        readonly res?: Response;
+        readonly status: import("hono/utils/http-status").ContentfulStatusCode;
+        getResponse(): Response;
+        readonly name: string;
+        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"> & {
+            error: "invalid_authorization_details";
+            reason: "scope_without_limit";
+        };
+    };
+    readonly reason: "scope_without_limit";
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+/** A scope calls a token no limit names. */
+export declare class ScopeWithoutLimitError extends ScopeWithoutLimitError_base {
+    readonly name = "KeyAuthorization.ScopeWithoutLimitError";
+}
+declare const UnsupportedCallError_base: {
+    new (options: ErrorResponse.define.Options): {
+        message: string;
+        stack?: string;
+        cause?: unknown;
+        readonly res?: Response;
+        readonly status: import("hono/utils/http-status").ContentfulStatusCode;
+        getResponse(): Response;
+        readonly name: string;
+        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"> & {
+            error: "invalid_authorization_details";
+            reason: "unsupported_call";
+        };
+    };
+    readonly reason: "unsupported_call";
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+/** A scope calls a function a key may not call. */
+export declare class UnsupportedCallError extends UnsupportedCallError_base {
+    readonly name = "KeyAuthorization.UnsupportedCallError";
+}
+declare const UnsupportedTokenError_base: {
+    new (options: ErrorResponse.define.Options): {
+        message: string;
+        stack?: string;
+        cause?: unknown;
+        readonly res?: Response;
+        readonly status: import("hono/utils/http-status").ContentfulStatusCode;
+        getResponse(): Response;
+        readonly name: string;
+        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"> & {
+            error: "invalid_authorization_details";
+            reason: "unsupported_token";
+        };
+    };
+    readonly reason: "unsupported_token";
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+/** A limit names a token that is not supported on the chain. */
+export declare class UnsupportedTokenError extends UnsupportedTokenError_base {
+    readonly name = "KeyAuthorization.UnsupportedTokenError";
+}
+declare const WebAuthnRequiredError_base: {
+    new (options: ErrorResponse.define.Options): {
+        message: string;
+        stack?: string;
+        cause?: unknown;
+        readonly res?: Response;
+        readonly status: import("hono/utils/http-status").ContentfulStatusCode;
+        getResponse(): Response;
+        readonly name: string;
+        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"> & {
+            error: "interaction_required";
+            reason: "webauthn_required";
+        };
+    };
+    readonly reason: "webauthn_required";
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+/** The key names a passkey-owned Tempo Account, whose passkey signs only on a Tempo ID page. */
+export declare class WebAuthnRequiredError extends WebAuthnRequiredError_base {
+    readonly name = "KeyAuthorization.WebAuthnRequiredError";
+    constructor(options: WebAuthnRequiredError.Options);
+}
+export declare namespace WebAuthnRequiredError {
+    type Options = {
+        /** The passkey-owned account. */
+        account: `0x${string}`;
+        /** The refusal's description, in place of the default that names the flows a passkey signs in. */
+        description?: string | undefined;
+    };
+}
+/**
+ * An app's key authorization request as sent: the shape of the Accounts SDK's `wallet_connect`
+ * `authorizeAccessKey` capability, with the user's Tempo Account it acts for.
+ */
+declare const sent: z.ZodObject<{
+    account: z.ZodOptional<z.ZodTemplateLiteral<`0x${string}`>>;
+    address: z.ZodOptional<z.ZodTemplateLiteral<`0x${string}`>>;
+    chainId: z.ZodOptional<z.ZodCodec<z.ZodUnion<readonly [z.ZodTemplateLiteral<`0x${string}`>, z.ZodBigInt]>, z.ZodBigInt>>;
+    expiry: z.ZodOptional<z.ZodNumber>;
+    keyType: z.ZodOptional<z.ZodEnum<{
+        p256: "p256";
+        secp256k1: "secp256k1";
+        webAuthn: "webAuthn";
+    }>>;
+    limits: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        limit: z.ZodCodec<z.ZodUnion<readonly [z.ZodTemplateLiteral<`0x${string}`>, z.ZodBigInt]>, z.ZodBigInt>;
+        period: z.ZodOptional<z.ZodNumber>;
+        token: z.ZodTemplateLiteral<`0x${string}`>;
+    }, z.core.$strip>>>>;
+    publicKey: z.ZodOptional<z.ZodTemplateLiteral<`0x${string}`>>;
+    scopes: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        address: z.ZodTemplateLiteral<`0x${string}`>;
+        recipients: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodTemplateLiteral<`0x${string}`>>>>;
+        selector: z.ZodOptional<z.ZodUnion<readonly [z.ZodTemplateLiteral<`0x${string}`>, z.ZodString]>>;
+    }, z.core.$strip>>>>;
+}, z.core.$strip>;
+/** Zod schemas for key authorization requests, and for the API's responses about them. */
+export declare namespace schema {
+    /** The Tempo Account a signed key acts for. */
+    const account: z.ZodTemplateLiteral<`0x${string}`>;
+    /** An app's key authorization request, with what it leaves out filled with the headless ceiling. */
+    const request: z.ZodOptional<z.ZodPipe<z.ZodObject<{
+        account: z.ZodOptional<z.ZodTemplateLiteral<`0x${string}`>>;
+        address: z.ZodOptional<z.ZodTemplateLiteral<`0x${string}`>>;
+        chainId: z.ZodOptional<z.ZodCodec<z.ZodUnion<readonly [z.ZodTemplateLiteral<`0x${string}`>, z.ZodBigInt]>, z.ZodBigInt>>;
+        expiry: z.ZodOptional<z.ZodNumber>;
+        keyType: z.ZodOptional<z.ZodEnum<{
+            p256: "p256";
+            secp256k1: "secp256k1";
+            webAuthn: "webAuthn";
+        }>>;
+        limits: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            limit: z.ZodCodec<z.ZodUnion<readonly [z.ZodTemplateLiteral<`0x${string}`>, z.ZodBigInt]>, z.ZodBigInt>;
+            period: z.ZodOptional<z.ZodNumber>;
+            token: z.ZodTemplateLiteral<`0x${string}`>;
+        }, z.core.$strip>>>>;
+        publicKey: z.ZodOptional<z.ZodTemplateLiteral<`0x${string}`>>;
+        scopes: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            address: z.ZodTemplateLiteral<`0x${string}`>;
+            recipients: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodTemplateLiteral<`0x${string}`>>>>;
+            selector: z.ZodOptional<z.ZodUnion<readonly [z.ZodTemplateLiteral<`0x${string}`>, z.ZodString]>>;
+        }, z.core.$strip>>>>;
+    }, z.core.$strip>, z.ZodTransform<Defaulted, {
+        account?: `0x${string}` | undefined;
+        address?: `0x${string}` | undefined;
+        chainId?: bigint | undefined;
+        expiry?: number | undefined;
+        keyType?: "p256" | "secp256k1" | "webAuthn" | undefined;
+        limits?: readonly {
+            limit: bigint;
+            period?: number | undefined;
+            token: `0x${string}`;
+        }[] | undefined;
+        publicKey?: `0x${string}` | undefined;
+        scopes?: readonly {
+            address: `0x${string}`;
+            recipients?: readonly `0x${string}`[] | undefined;
+            selector?: string | undefined;
+        }[] | undefined;
+    }>>>;
+    /** What a key grants, as `describe` returns it for the approval screens. */
+    const description: z.ZodObject<{
+        account: z.ZodOptional<z.ZodTemplateLiteral<`0x${string}`>>;
+        expiry: z.ZodNumber;
+        limits: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            amount: z.ZodString;
+            currency: z.ZodString;
+            period: z.ZodOptional<z.ZodNumber>;
+            tokens: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                amount: z.ZodString;
+                symbol: z.ZodString;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+    /** A signed key authorization in the node's RPC format, as `sign` returns it. */
+    const rpc: z.ZodObject<{
+        account: z.ZodOptional<z.ZodNullable<z.ZodTemplateLiteral<`0x${string}`>>>;
+        allowedCalls: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            selectorRules: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                recipients: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodTemplateLiteral<`0x${string}`>>>>;
+                selector: z.ZodTemplateLiteral<`0x${string}`>;
+            }, z.core.$strip>>>>;
+            target: z.ZodTemplateLiteral<`0x${string}`>;
+        }, z.core.$strip>>>>;
+        chainId: z.ZodTemplateLiteral<`0x${string}`>;
+        expiry: z.ZodOptional<z.ZodNullable<z.ZodTemplateLiteral<`0x${string}`>>>;
+        keyId: z.ZodTemplateLiteral<`0x${string}`>;
+        keyType: z.ZodString;
+        limits: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            limit: z.ZodTemplateLiteral<`0x${string}`>;
+            period: z.ZodOptional<z.ZodTemplateLiteral<`0x${string}`>>;
+            token: z.ZodTemplateLiteral<`0x${string}`>;
+        }, z.core.$strip>>>>;
+        signature: z.ZodUnion<readonly [z.ZodTemplateLiteral<`0x${string}`>, z.ZodDiscriminatedUnion<[z.ZodObject<{
+            r: z.ZodTemplateLiteral<`0x${string}`>;
+            s: z.ZodTemplateLiteral<`0x${string}`>;
+            type: z.ZodLiteral<"secp256k1">;
+            v: z.ZodOptional<z.ZodTemplateLiteral<`0x${string}`>>;
+            yParity: z.ZodTemplateLiteral<`0x${string}`>;
+        }, z.core.$strip>, z.ZodObject<{
+            preHash: z.ZodBoolean;
+            pubKeyX: z.ZodTemplateLiteral<`0x${string}`>;
+            pubKeyY: z.ZodTemplateLiteral<`0x${string}`>;
+            r: z.ZodTemplateLiteral<`0x${string}`>;
+            s: z.ZodTemplateLiteral<`0x${string}`>;
+            type: z.ZodLiteral<"p256">;
+        }, z.core.$strip>, z.ZodObject<{
+            pubKeyX: z.ZodTemplateLiteral<`0x${string}`>;
+            pubKeyY: z.ZodTemplateLiteral<`0x${string}`>;
+            r: z.ZodTemplateLiteral<`0x${string}`>;
+            s: z.ZodTemplateLiteral<`0x${string}`>;
+            type: z.ZodLiteral<"webAuthn">;
+            webauthnData: z.ZodTemplateLiteral<`0x${string}`>;
+        }, z.core.$strip>], "type">, z.ZodObject<{
+            keyId: z.ZodOptional<z.ZodTemplateLiteral<`0x${string}`>>;
+            signature: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                r: z.ZodTemplateLiteral<`0x${string}`>;
+                s: z.ZodTemplateLiteral<`0x${string}`>;
+                type: z.ZodLiteral<"secp256k1">;
+                v: z.ZodOptional<z.ZodTemplateLiteral<`0x${string}`>>;
+                yParity: z.ZodTemplateLiteral<`0x${string}`>;
+            }, z.core.$strip>, z.ZodObject<{
+                preHash: z.ZodBoolean;
+                pubKeyX: z.ZodTemplateLiteral<`0x${string}`>;
+                pubKeyY: z.ZodTemplateLiteral<`0x${string}`>;
+                r: z.ZodTemplateLiteral<`0x${string}`>;
+                s: z.ZodTemplateLiteral<`0x${string}`>;
+                type: z.ZodLiteral<"p256">;
+            }, z.core.$strip>, z.ZodObject<{
+                pubKeyX: z.ZodTemplateLiteral<`0x${string}`>;
+                pubKeyY: z.ZodTemplateLiteral<`0x${string}`>;
+                r: z.ZodTemplateLiteral<`0x${string}`>;
+                s: z.ZodTemplateLiteral<`0x${string}`>;
+                type: z.ZodLiteral<"webAuthn">;
+                webauthnData: z.ZodTemplateLiteral<`0x${string}`>;
+            }, z.core.$strip>], "type">;
+            type: z.ZodLiteral<"keychain">;
+            userAddress: z.ZodTemplateLiteral<`0x${string}`>;
+            version: z.ZodOptional<z.ZodEnum<{
+                v1: "v1";
+                v2: "v2";
+            }>>;
+        }, z.core.$strip>]>;
+        witness: z.ZodOptional<z.ZodTemplateLiteral<`0x${string}`>>;
+    }, z.core.$strip>;
+}
+/** An app's key authorization request. */
+export type Key = NonNullable<z.output<typeof schema.request>>;
+/** A key authorization request as sent. */
+type Request = z.output<typeof sent>;
+/** A key authorization request with every default filled. */
+type Defaulted = Request & {
+    chainId: bigint;
+    expiry: number;
+    limits: NonNullable<Request['limits']>;
+    scopes: NonNullable<Request['scopes']>;
+    /** The witness the owner's signature binds, which Tempo ID derives from a request's challenge. */
+    witness?: Hex.Hex | undefined;
+};
+/** The longest a headless key lasts, in seconds, and how long a key lasts when its request names no expiry. */
+export declare const lifetime: number;
+/** Tempo chains, whose token addresses Viem's token list holds. */
+export declare const chains: ({
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Tempo Explorer";
+            readonly url: "https://explore.devnet.tempo.xyz";
+        };
+    };
+    blockTime: 1000;
+    contracts?: {
+        [x: string]: import("viem").ChainContract | {
+            [sourceId: number]: import("viem").ChainContract | undefined;
+        } | undefined;
+        ensRegistry?: import("viem").ChainContract | undefined;
+        ensUniversalResolver?: import("viem").ChainContract | undefined;
+        multicall3?: import("viem").ChainContract | undefined;
+        erc6492Verifier?: import("viem").ChainContract | undefined;
+    } | undefined;
+    ensTlds?: readonly string[] | undefined;
+    id: 31318;
+    name: "Tempo Devnet";
+    nativeCurrency: {
+        readonly name: "USD";
+        readonly symbol: "USD";
+        readonly decimals: 6;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://rpc.devnet.tempoxyz.dev"];
+            readonly webSocket: readonly ["wss://rpc.devnet.tempoxyz.dev"];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    supportsTransactionReplacementDetection?: boolean | undefined | undefined;
+    testnet: true;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema: {
+        feeToken?: import("viem/chains").TokenIdOrAddress | undefined;
+        hardfork?: ("genesis" | "t0" | "t1" | "t1a" | "t1b" | "t1c" | "t2" | "t3" | "t4" | "t5" | "t6") | undefined;
+    };
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters: {
+        readonly transaction: {
+            exclude: never[] | undefined;
+            format: (args: import("viem/tempo").z_TransactionRpc, action?: string | undefined) => import("viem/tempo").z_Transaction<bigint, number, boolean>;
+            type: "transaction";
+        };
+        readonly transactionReceipt: {
+            exclude: [] | undefined;
+            format: (args: import("viem/tempo").z_TransactionReceiptRpc, action?: string | undefined) => import("viem/tempo").z_TransactionReceipt;
+            type: "transactionReceipt";
+        };
+        readonly transactionRequest: {
+            exclude: [] | undefined;
+            format: (args: import("viem/tempo").z_TransactionRequest, action?: string | undefined) => import("viem/tempo").z_TransactionRequestRpc;
+            type: "transactionRequest";
+        };
+    };
+    prepareTransactionRequest: [(r: import("viem").PrepareTransactionRequestParameters, { client, phase }: {
+        client: import("viem").Client;
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>, {
+        readonly runAt: readonly ["beforeFillTransaction", "afterFillParameters"];
+    }];
+    serializers: {
+        readonly transaction: import("viem").SerializeTransactionFn;
+        readonly transactionEnvelope: ({ serializedTransaction, transaction }: {
+            serializedTransaction: import("viem").TransactionSerializedGeneric;
+            transaction: import("viem").TransactionSerializable;
+        }) => Promise<`0x${string}`>;
+    };
+    verifyHash: (client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<boolean>;
+    readonly hardfork: "t3";
+    extend: <const extended_1 extends {
+        feeToken?: import("viem/chains").TokenIdOrAddress | undefined;
+        hardfork?: ("genesis" | "t0" | "t1" | "t1a" | "t1b" | "t1c" | "t2" | "t3" | "t4" | "t5" | "t6") | undefined;
+    }>(extended: extended_1) => import("viem").Assign<import("viem").Assign<import("viem").Chain<undefined>, {
+        readonly id: 31318;
+        readonly name: "Tempo Devnet";
+        readonly hardfork: "t3";
+        readonly blockExplorers: {
+            readonly default: {
+                readonly name: "Tempo Explorer";
+                readonly url: "https://explore.devnet.tempo.xyz";
+            };
+        };
+        readonly nativeCurrency: {
+            readonly name: "USD";
+            readonly symbol: "USD";
+            readonly decimals: 6;
+        };
+        readonly rpcUrls: {
+            readonly default: {
+                readonly http: readonly ["https://rpc.devnet.tempoxyz.dev"];
+                readonly webSocket: readonly ["wss://rpc.devnet.tempoxyz.dev"];
+            };
+        };
+        readonly testnet: true;
+        readonly blockTime: 1000;
+        readonly extendSchema: {
+            feeToken?: import("viem/chains").TokenIdOrAddress | undefined;
+            hardfork?: ("genesis" | "t0" | "t1" | "t1a" | "t1b" | "t1c" | "t2" | "t3" | "t4" | "t5" | "t6") | undefined;
+        };
+        readonly formatters: {
+            readonly transaction: {
+                exclude: never[] | undefined;
+                format: (args: import("viem/tempo").z_TransactionRpc, action?: string | undefined) => import("viem/tempo").z_Transaction<bigint, number, boolean>;
+                type: "transaction";
+            };
+            readonly transactionReceipt: {
+                exclude: [] | undefined;
+                format: (args: import("viem/tempo").z_TransactionReceiptRpc, action?: string | undefined) => import("viem/tempo").z_TransactionReceipt;
+                type: "transactionReceipt";
+            };
+            readonly transactionRequest: {
+                exclude: [] | undefined;
+                format: (args: import("viem/tempo").z_TransactionRequest, action?: string | undefined) => import("viem/tempo").z_TransactionRequestRpc;
+                type: "transactionRequest";
+            };
+        };
+        readonly prepareTransactionRequest: [(r: import("viem").PrepareTransactionRequestParameters, { client, phase }: {
+            client: import("viem").Client;
+            phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+        }) => Promise<import("viem").PrepareTransactionRequestParameters>, {
+            readonly runAt: readonly ["beforeFillTransaction", "afterFillParameters"];
+        }];
+        readonly serializers: {
+            readonly transaction: import("viem").SerializeTransactionFn;
+            readonly transactionEnvelope: ({ serializedTransaction, transaction }: {
+                serializedTransaction: import("viem").TransactionSerializedGeneric;
+                transaction: import("viem").TransactionSerializable;
+            }) => Promise<`0x${string}`>;
+        };
+        readonly verifyHash: (client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<boolean>;
+    }>, extended_1>;
+} | {
+    blockExplorers?: {
+        [key: string]: {
+            name: string;
+            url: string;
+            apiUrl?: string | undefined;
+        };
+        default: {
+            name: string;
+            url: string;
+            apiUrl?: string | undefined;
+        };
+    } | undefined | undefined;
+    blockTime: 1000;
+    contracts?: {
+        [x: string]: import("viem").ChainContract | {
+            [sourceId: number]: import("viem").ChainContract | undefined;
+        } | undefined;
+        ensRegistry?: import("viem").ChainContract | undefined;
+        ensUniversalResolver?: import("viem").ChainContract | undefined;
+        multicall3?: import("viem").ChainContract | undefined;
+        erc6492Verifier?: import("viem").ChainContract | undefined;
+    } | undefined;
+    ensTlds?: readonly string[] | undefined;
+    id: 1337;
+    name: "Tempo";
+    nativeCurrency: {
+        readonly name: "USD";
+        readonly symbol: "USD";
+        readonly decimals: 6;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["http://localhost:8545"];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    supportsTransactionReplacementDetection?: boolean | undefined | undefined;
+    testnet?: boolean | undefined | undefined;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema: {
+        feeToken?: import("viem/chains").TokenIdOrAddress | undefined;
+        hardfork?: ("genesis" | "t0" | "t1" | "t1a" | "t1b" | "t1c" | "t2" | "t3" | "t4" | "t5" | "t6") | undefined;
+    };
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters: {
+        readonly transaction: {
+            exclude: never[] | undefined;
+            format: (args: import("viem/tempo").z_TransactionRpc, action?: string | undefined) => import("viem/tempo").z_Transaction<bigint, number, boolean>;
+            type: "transaction";
+        };
+        readonly transactionReceipt: {
+            exclude: [] | undefined;
+            format: (args: import("viem/tempo").z_TransactionReceiptRpc, action?: string | undefined) => import("viem/tempo").z_TransactionReceipt;
+            type: "transactionReceipt";
+        };
+        readonly transactionRequest: {
+            exclude: [] | undefined;
+            format: (args: import("viem/tempo").z_TransactionRequest, action?: string | undefined) => import("viem/tempo").z_TransactionRequestRpc;
+            type: "transactionRequest";
+        };
+    };
+    prepareTransactionRequest: [(r: import("viem").PrepareTransactionRequestParameters, { client, phase }: {
+        client: import("viem").Client;
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>, {
+        readonly runAt: readonly ["beforeFillTransaction", "afterFillParameters"];
+    }];
+    serializers: {
+        readonly transaction: import("viem").SerializeTransactionFn;
+        readonly transactionEnvelope: ({ serializedTransaction, transaction }: {
+            serializedTransaction: import("viem").TransactionSerializedGeneric;
+            transaction: import("viem").TransactionSerializable;
+        }) => Promise<`0x${string}`>;
+    };
+    verifyHash: (client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<boolean>;
+    readonly hardfork: "t3";
+    extend: <const extended_1 extends {
+        feeToken?: import("viem/chains").TokenIdOrAddress | undefined;
+        hardfork?: ("genesis" | "t0" | "t1" | "t1a" | "t1b" | "t1c" | "t2" | "t3" | "t4" | "t5" | "t6") | undefined;
+    }>(extended: extended_1) => import("viem").Assign<import("viem").Assign<import("viem").Chain<undefined>, {
+        readonly id: 1337;
+        readonly name: "Tempo";
+        readonly hardfork: "t3";
+        readonly nativeCurrency: {
+            readonly name: "USD";
+            readonly symbol: "USD";
+            readonly decimals: 6;
+        };
+        readonly rpcUrls: {
+            readonly default: {
+                readonly http: readonly ["http://localhost:8545"];
+            };
+        };
+        readonly blockTime: 1000;
+        readonly extendSchema: {
+            feeToken?: import("viem/chains").TokenIdOrAddress | undefined;
+            hardfork?: ("genesis" | "t0" | "t1" | "t1a" | "t1b" | "t1c" | "t2" | "t3" | "t4" | "t5" | "t6") | undefined;
+        };
+        readonly formatters: {
+            readonly transaction: {
+                exclude: never[] | undefined;
+                format: (args: import("viem/tempo").z_TransactionRpc, action?: string | undefined) => import("viem/tempo").z_Transaction<bigint, number, boolean>;
+                type: "transaction";
+            };
+            readonly transactionReceipt: {
+                exclude: [] | undefined;
+                format: (args: import("viem/tempo").z_TransactionReceiptRpc, action?: string | undefined) => import("viem/tempo").z_TransactionReceipt;
+                type: "transactionReceipt";
+            };
+            readonly transactionRequest: {
+                exclude: [] | undefined;
+                format: (args: import("viem/tempo").z_TransactionRequest, action?: string | undefined) => import("viem/tempo").z_TransactionRequestRpc;
+                type: "transactionRequest";
+            };
+        };
+        readonly prepareTransactionRequest: [(r: import("viem").PrepareTransactionRequestParameters, { client, phase }: {
+            client: import("viem").Client;
+            phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+        }) => Promise<import("viem").PrepareTransactionRequestParameters>, {
+            readonly runAt: readonly ["beforeFillTransaction", "afterFillParameters"];
+        }];
+        readonly serializers: {
+            readonly transaction: import("viem").SerializeTransactionFn;
+            readonly transactionEnvelope: ({ serializedTransaction, transaction }: {
+                serializedTransaction: import("viem").TransactionSerializedGeneric;
+                transaction: import("viem").TransactionSerializable;
+            }) => Promise<`0x${string}`>;
+        };
+        readonly verifyHash: (client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<boolean>;
+    }>, extended_1>;
+} | {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Tempo Explorer";
+            readonly url: "https://explore.testnet.tempo.xyz";
+        };
+    };
+    blockTime: 1000;
+    contracts: {
+        readonly earnFactory: {
+            readonly address: "0x1de6B233984583F4d936ae4265f3b60282b70cc6";
+        };
+        readonly erc4626EngineFactory: {
+            readonly address: "0x0d57c10249eb3a92b7d81bBA6221F80F2865448A";
+        };
+    };
+    ensTlds?: readonly string[] | undefined;
+    id: 42431;
+    name: "Tempo Testnet (Moderato)";
+    nativeCurrency: {
+        readonly name: "USD";
+        readonly symbol: "USD";
+        readonly decimals: 6;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://rpc.moderato.tempo.xyz"];
+            readonly webSocket: readonly ["wss://rpc.moderato.tempo.xyz"];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    supportsTransactionReplacementDetection?: boolean | undefined | undefined;
+    testnet: true;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema: {
+        feeToken?: import("viem/chains").TokenIdOrAddress | undefined;
+        hardfork?: ("genesis" | "t0" | "t1" | "t1a" | "t1b" | "t1c" | "t2" | "t3" | "t4" | "t5" | "t6") | undefined;
+    };
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters: {
+        readonly transaction: {
+            exclude: never[] | undefined;
+            format: (args: import("viem/tempo").z_TransactionRpc, action?: string | undefined) => import("viem/tempo").z_Transaction<bigint, number, boolean>;
+            type: "transaction";
+        };
+        readonly transactionReceipt: {
+            exclude: [] | undefined;
+            format: (args: import("viem/tempo").z_TransactionReceiptRpc, action?: string | undefined) => import("viem/tempo").z_TransactionReceipt;
+            type: "transactionReceipt";
+        };
+        readonly transactionRequest: {
+            exclude: [] | undefined;
+            format: (args: import("viem/tempo").z_TransactionRequest, action?: string | undefined) => import("viem/tempo").z_TransactionRequestRpc;
+            type: "transactionRequest";
+        };
+    };
+    prepareTransactionRequest: [(r: import("viem").PrepareTransactionRequestParameters, { client, phase }: {
+        client: import("viem").Client;
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>, {
+        readonly runAt: readonly ["beforeFillTransaction", "afterFillParameters"];
+    }];
+    serializers: {
+        readonly transaction: import("viem").SerializeTransactionFn;
+        readonly transactionEnvelope: ({ serializedTransaction, transaction }: {
+            serializedTransaction: import("viem").TransactionSerializedGeneric;
+            transaction: import("viem").TransactionSerializable;
+        }) => Promise<`0x${string}`>;
+    };
+    verifyHash: (client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<boolean>;
+    readonly hardfork: "t5";
+    extend: <const extended_1 extends {
+        feeToken?: import("viem/chains").TokenIdOrAddress | undefined;
+        hardfork?: ("genesis" | "t0" | "t1" | "t1a" | "t1b" | "t1c" | "t2" | "t3" | "t4" | "t5" | "t6") | undefined;
+    }>(extended: extended_1) => import("viem").Assign<import("viem").Assign<import("viem").Chain<undefined>, {
+        readonly id: 42431;
+        readonly hardfork: "t5";
+        readonly blockExplorers: {
+            readonly default: {
+                readonly name: "Tempo Explorer";
+                readonly url: "https://explore.testnet.tempo.xyz";
+            };
+        };
+        readonly contracts: {
+            readonly earnFactory: {
+                readonly address: "0x1de6B233984583F4d936ae4265f3b60282b70cc6";
+            };
+            readonly erc4626EngineFactory: {
+                readonly address: "0x0d57c10249eb3a92b7d81bBA6221F80F2865448A";
+            };
+        };
+        readonly name: "Tempo Testnet (Moderato)";
+        readonly nativeCurrency: {
+            readonly name: "USD";
+            readonly symbol: "USD";
+            readonly decimals: 6;
+        };
+        readonly rpcUrls: {
+            readonly default: {
+                readonly http: readonly ["https://rpc.moderato.tempo.xyz"];
+                readonly webSocket: readonly ["wss://rpc.moderato.tempo.xyz"];
+            };
+        };
+        readonly testnet: true;
+        readonly blockTime: 1000;
+        readonly extendSchema: {
+            feeToken?: import("viem/chains").TokenIdOrAddress | undefined;
+            hardfork?: ("genesis" | "t0" | "t1" | "t1a" | "t1b" | "t1c" | "t2" | "t3" | "t4" | "t5" | "t6") | undefined;
+        };
+        readonly formatters: {
+            readonly transaction: {
+                exclude: never[] | undefined;
+                format: (args: import("viem/tempo").z_TransactionRpc, action?: string | undefined) => import("viem/tempo").z_Transaction<bigint, number, boolean>;
+                type: "transaction";
+            };
+            readonly transactionReceipt: {
+                exclude: [] | undefined;
+                format: (args: import("viem/tempo").z_TransactionReceiptRpc, action?: string | undefined) => import("viem/tempo").z_TransactionReceipt;
+                type: "transactionReceipt";
+            };
+            readonly transactionRequest: {
+                exclude: [] | undefined;
+                format: (args: import("viem/tempo").z_TransactionRequest, action?: string | undefined) => import("viem/tempo").z_TransactionRequestRpc;
+                type: "transactionRequest";
+            };
+        };
+        readonly prepareTransactionRequest: [(r: import("viem").PrepareTransactionRequestParameters, { client, phase }: {
+            client: import("viem").Client;
+            phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+        }) => Promise<import("viem").PrepareTransactionRequestParameters>, {
+            readonly runAt: readonly ["beforeFillTransaction", "afterFillParameters"];
+        }];
+        readonly serializers: {
+            readonly transaction: import("viem").SerializeTransactionFn;
+            readonly transactionEnvelope: ({ serializedTransaction, transaction }: {
+                serializedTransaction: import("viem").TransactionSerializedGeneric;
+                transaction: import("viem").TransactionSerializable;
+            }) => Promise<`0x${string}`>;
+        };
+        readonly verifyHash: (client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<boolean>;
+    }>, extended_1>;
+} | {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Tempo Explorer";
+            readonly url: "https://explore.tempo.xyz";
+        };
+    };
+    blockTime: 1000;
+    contracts: {
+        readonly earnFactory: {
+            readonly address: "0x3085A8003f340CD51C72D9e1a1298CDafB171B02";
+        };
+        readonly erc4626EngineFactory: {
+            readonly address: "0xd43D00981222a8db444A528E69f19E3cE5A7D2Ff";
+        };
+    };
+    ensTlds?: readonly string[] | undefined;
+    id: 4217;
+    name: "Tempo Mainnet";
+    nativeCurrency: {
+        readonly name: "USD";
+        readonly symbol: "USD";
+        readonly decimals: 6;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://rpc.tempo.xyz"];
+            readonly webSocket: readonly ["wss://rpc.tempo.xyz"];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    supportsTransactionReplacementDetection?: boolean | undefined | undefined;
+    testnet?: boolean | undefined | undefined;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema: {
+        feeToken?: import("viem/chains").TokenIdOrAddress | undefined;
+        hardfork?: ("genesis" | "t0" | "t1" | "t1a" | "t1b" | "t1c" | "t2" | "t3" | "t4" | "t5" | "t6") | undefined;
+    };
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters: {
+        readonly transaction: {
+            exclude: never[] | undefined;
+            format: (args: import("viem/tempo").z_TransactionRpc, action?: string | undefined) => import("viem/tempo").z_Transaction<bigint, number, boolean>;
+            type: "transaction";
+        };
+        readonly transactionReceipt: {
+            exclude: [] | undefined;
+            format: (args: import("viem/tempo").z_TransactionReceiptRpc, action?: string | undefined) => import("viem/tempo").z_TransactionReceipt;
+            type: "transactionReceipt";
+        };
+        readonly transactionRequest: {
+            exclude: [] | undefined;
+            format: (args: import("viem/tempo").z_TransactionRequest, action?: string | undefined) => import("viem/tempo").z_TransactionRequestRpc;
+            type: "transactionRequest";
+        };
+    };
+    prepareTransactionRequest: [(r: import("viem").PrepareTransactionRequestParameters, { client, phase }: {
+        client: import("viem").Client;
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>, {
+        readonly runAt: readonly ["beforeFillTransaction", "afterFillParameters"];
+    }];
+    serializers: {
+        readonly transaction: import("viem").SerializeTransactionFn;
+        readonly transactionEnvelope: ({ serializedTransaction, transaction }: {
+            serializedTransaction: import("viem").TransactionSerializedGeneric;
+            transaction: import("viem").TransactionSerializable;
+        }) => Promise<`0x${string}`>;
+    };
+    verifyHash: (client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<boolean>;
+    extend: <const extended_1 extends {
+        feeToken?: import("viem/chains").TokenIdOrAddress | undefined;
+        hardfork?: ("genesis" | "t0" | "t1" | "t1a" | "t1b" | "t1c" | "t2" | "t3" | "t4" | "t5" | "t6") | undefined;
+    }>(extended: extended_1) => import("viem").Assign<import("viem").Assign<import("viem").Chain<undefined>, {
+        readonly id: 4217;
+        readonly blockExplorers: {
+            readonly default: {
+                readonly name: "Tempo Explorer";
+                readonly url: "https://explore.tempo.xyz";
+            };
+        };
+        readonly contracts: {
+            readonly earnFactory: {
+                readonly address: "0x3085A8003f340CD51C72D9e1a1298CDafB171B02";
+            };
+            readonly erc4626EngineFactory: {
+                readonly address: "0xd43D00981222a8db444A528E69f19E3cE5A7D2Ff";
+            };
+        };
+        readonly name: "Tempo Mainnet";
+        readonly nativeCurrency: {
+            readonly name: "USD";
+            readonly symbol: "USD";
+            readonly decimals: 6;
+        };
+        readonly rpcUrls: {
+            readonly default: {
+                readonly http: readonly ["https://rpc.tempo.xyz"];
+                readonly webSocket: readonly ["wss://rpc.tempo.xyz"];
+            };
+        };
+        readonly blockTime: 1000;
+        readonly extendSchema: {
+            feeToken?: import("viem/chains").TokenIdOrAddress | undefined;
+            hardfork?: ("genesis" | "t0" | "t1" | "t1a" | "t1b" | "t1c" | "t2" | "t3" | "t4" | "t5" | "t6") | undefined;
+        };
+        readonly formatters: {
+            readonly transaction: {
+                exclude: never[] | undefined;
+                format: (args: import("viem/tempo").z_TransactionRpc, action?: string | undefined) => import("viem/tempo").z_Transaction<bigint, number, boolean>;
+                type: "transaction";
+            };
+            readonly transactionReceipt: {
+                exclude: [] | undefined;
+                format: (args: import("viem/tempo").z_TransactionReceiptRpc, action?: string | undefined) => import("viem/tempo").z_TransactionReceipt;
+                type: "transactionReceipt";
+            };
+            readonly transactionRequest: {
+                exclude: [] | undefined;
+                format: (args: import("viem/tempo").z_TransactionRequest, action?: string | undefined) => import("viem/tempo").z_TransactionRequestRpc;
+                type: "transactionRequest";
+            };
+        };
+        readonly prepareTransactionRequest: [(r: import("viem").PrepareTransactionRequestParameters, { client, phase }: {
+            client: import("viem").Client;
+            phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+        }) => Promise<import("viem").PrepareTransactionRequestParameters>, {
+            readonly runAt: readonly ["beforeFillTransaction", "afterFillParameters"];
+        }];
+        readonly serializers: {
+            readonly transaction: import("viem").SerializeTransactionFn;
+            readonly transactionEnvelope: ({ serializedTransaction, transaction }: {
+                serializedTransaction: import("viem").TransactionSerializedGeneric;
+                transaction: import("viem").TransactionSerializable;
+            }) => Promise<`0x${string}`>;
+        };
+        readonly verifyHash: (client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<boolean>;
+    }>, extended_1>;
+})[];
+/** The ID of the chain that a key acts on when its request names none: Tempo mainnet. */
+export declare const defaultChainId: 4217;
+/**
+ * Returns `key` with the witness of `challenge`: its EIP-191 hash, as `hashMessage` computes it, so
+ * a verifier checks the witness against the message it issued. Returns `key` unchanged without one.
+ */
+export declare function bind(key: Key, options: bind.Options): Key;
+export declare namespace bind {
+    type Options = {
+        /** The app's challenge, such as a sign-in message its backend issued. */
+        challenge: string | undefined;
+    };
+}
+/**
+ * Why `key` breaks the rules every flow applies, with the field at fault and the values compared,
+ * or `undefined` when the owner may sign it. Fields are request paths under `key_authorization`,
+ * where every request carries the key.
+ */
+export declare function check(key: Key): ErrorResponse.Instance<typeof check.errors> | undefined;
+export declare namespace check {
+    /** The refusals `check` returns. Its return type admits no other. */
+    const errors: readonly [typeof DuplicateLimitError, typeof DuplicateScopeError, typeof EmptyLimitsError, typeof EmptyScopesError, typeof ExpiryPassedError, typeof InvalidChainError, typeof InvalidExpiryError, typeof InvalidPeriodError, typeof InvalidPublicKeyError, typeof InvalidRecipientsError, typeof MissingKeyError, typeof MissingRecipientsError, typeof ScopeWithoutLimitError, typeof UnsupportedCallError, typeof UnsupportedTokenError];
+}
+/**
+ * Why the request for `key` is refused for the app `app`. The request carries a challenge, which
+ * became the key's witness, and the app does not hold the `tempo-id:sign` scope. Returns `undefined`
+ * when the key has no witness or the app holds the scope. A browser request names a redirect URI on
+ * its own origin, which the app registers, so the app's scope covers its pages.
+ */
+export declare function checkChallenge(options: checkChallenge.Options): ErrorResponse.Instance<typeof checkChallenge.errors> | undefined;
+export declare namespace checkChallenge {
+    type Options = {
+        /** The app that requests the key, or `undefined` when no app has `clientId`. */
+        app: Pick<Apps.App, 'sign'> | undefined;
+        /** The client ID of the app that requests the key. */
+        clientId: string;
+        /** The requested key authorization. A key without a `witness`, or no key, passes. */
+        key: Key | undefined;
+    };
+    /** The refusals `checkChallenge` returns. */
+    const errors: readonly [typeof ChallengeNotPermittedError];
+}
+/**
+ * Why `key` is refused in a flow that shows the user nothing: the rules `check` applies, then the
+ * headless ceiling. Returns `undefined` when the owner may sign it.
+ */
+export declare function checkHeadless(key: Key): ErrorResponse.Instance<typeof checkHeadless.errors> | undefined;
+export declare namespace checkHeadless {
+    /** The refusals `checkHeadless` returns: `check`'s, then the headless ceiling's. */
+    const errors: readonly [typeof DuplicateLimitError, typeof DuplicateScopeError, typeof EmptyLimitsError, typeof EmptyScopesError, typeof ExpiryPassedError, typeof InvalidChainError, typeof InvalidExpiryError, typeof InvalidPeriodError, typeof InvalidPublicKeyError, typeof InvalidRecipientsError, typeof MissingKeyError, typeof MissingRecipientsError, typeof ScopeWithoutLimitError, typeof UnsupportedCallError, typeof UnsupportedTokenError, typeof ExpiryExceedsMaximumError, typeof LimitExceedsMaximumError];
+}
+/**
+ * What a `key` that passes `check` grants, as the approval screens show it: its limits totaled per
+ * currency and period, and its expiry.
+ */
+export declare function describe(key: Key): Description;
+/** What a key grants, as the approval screens show it. */
+export type Description = z.output<typeof schema.description>;
+/**
+ * Returns the digest that an account's owner signs for `key`, which a passkey owner signs as its
+ * WebAuthn challenge. An owner's digest binds no account, so it is known before the passkey is.
+ * `witness` replaces the key's own, as a one-tap sign-in binds it.
+ */
+export declare function digest(options: digest.Options): `0x${string}`;
+export declare namespace digest {
+    type Options = {
+        /** The key authorization the digest commits to. */
+        key: Key;
+        /** The witness the digest binds, in place of the key's own. Absent, the key's own applies. */
+        witness?: Hex.Hex | undefined;
+    };
+}
+/** Returns the access key's address, which `publicKey` stands in for when the request names none. */
+export declare function keyId(key: Key): `0x${string}`;
+/** Returns the tokens of Viem's token list on the chain with `chainId`, as keys limit them. */
+export declare function listings(options: listings.Options): {
+    address: Address.Address;
+    cap: bigint;
+    currency: string;
+    decimals: number;
+    symbol: string;
+}[];
+export declare namespace listings {
+    type Options = {
+        /** The chain's ID. */
+        chainId: number;
+    };
+}
+/**
+ * Signs `key` with `owner`, the account's owner key, and returns the signed authorization in the
+ * node's RPC format. A Privy owner signs through Privy with the user's token.
+ */
+export declare function sign(owner: Parameters<typeof Account.signKeyAuthorization>[0], options: sign.Options): Promise<KeyAuthorization.Rpc>;
+export declare namespace sign {
+    type Options = {
+        /** The key authorization to sign, which `check` accepts. */
+        key: Key;
+    };
+}
+/**
+ * Signs `key` with `assertion`, a passkey's assertion over the key's {@link digest} that
+ * `Passkey.verify` accepted, and returns the signed authorization in the node's RPC format. The
+ * assertion becomes the authorization's WebAuthn signature envelope.
+ */
+export declare function signWithAssertion(assertion: Passkey.Assertion, options: signWithAssertion.Options): Promise<KeyAuthorization.Rpc>;
+export declare namespace signWithAssertion {
+    type Options = {
+        /** The key authorization that the assertion signs. */
+        key: Key;
+        /** The passkey's uncompressed P256 public key, hex. */
+        publicKey: Hex.Hex;
+    };
+}
+export {};
+//# sourceMappingURL=KeyAuthorization.d.ts.map