@tempoxyz/id 0.0.0-stage → 0.0.1

package/dist/internal/KeyAuthorization.d.ts

@@ -0,0 +1,1650 @@
+/**
+ * Access keys (TIP-1011) that apps hold on a user's Tempo Account, in the shape of the Accounts
+ * SDK's `wallet_connect` capability. The user approves a key on a page, or it fits the headless
+ * ceiling. A challenge becomes the key's witness (TIP-1053).
+ * @module
+ */
+import { Address, Hex } from 'ox';
+import { AccountConfig, 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 one call on a target, or one target mixes any function with named ones. */
+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` repeats an address, names the zero address, or is on the wrong call. */
+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 MissingPermissionsError_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_permissions";
+        };
+    };
+    readonly reason: "missing_permissions";
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+/** A third-party app's key request leaves out `expiry`, `limits`, or `scopes`. */
+export declare class MissingPermissionsError extends MissingPermissionsError_base {
+    readonly name = "KeyAuthorization.MissingPermissionsError";
+}
+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 listed token that 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 selector does not parse, a TIP-20 scope allows any function, or a headless call is unknown. */
+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}`;
+        /** Replaces the default `error_description`. */
+        description?: string | undefined;
+    };
+}
+/** An app's key authorization request as sent, with the 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 responses. */
+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 the headless ceiling as its defaults. */
+    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. */
+    const description: z.ZodObject<{
+        account: z.ZodOptional<z.ZodTemplateLiteral<`0x${string}`>>;
+        calls: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            call: z.ZodEnum<{
+                open: "open";
+                topUp: "topUp";
+            }>;
+        }, z.core.$strip>>>;
+        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>>>;
+        unrecognized: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            address: z.ZodTemplateLiteral<`0x${string}`>;
+            selector: z.ZodOptional<z.ZodTemplateLiteral<`0x${string}`>>;
+        }, 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 that the owner's signature binds, from the request's challenge. */
+    witness?: Hex.Hex | undefined;
+};
+/** A key's default lifetime, and a headless key's longest, in seconds. */
+export declare const lifetime: number;
+/** Tempo chains, whose token addresses Viem's token list holds. */
+export declare const chains: readonly [{
+    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" | "t10" | "t11" | "t12" | "t13" | "t14" | "t1a" | "t1b" | "t1c" | "t2" | "t3" | "t4" | "t5" | "t6" | "t7" | "t8" | "t9") | 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}`>;
+    };
+    transactionReplacement: {
+        readonly getKey: (transaction: {
+            from: import("viem").Address;
+            hash: `0x${string}`;
+            nonce: number;
+        }) => string;
+        readonly getReason: ({ replaced, replacement }: {
+            replaced: {
+                from: import("viem").Address;
+                hash: `0x${string}`;
+                nonce: number;
+            };
+            replacement: {
+                from: import("viem").Address;
+                hash: `0x${string}`;
+                nonce: number;
+            };
+        }) => import("viem").ReplacementReason;
+    };
+    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" | "t10" | "t11" | "t12" | "t13" | "t14" | "t1a" | "t1b" | "t1c" | "t2" | "t3" | "t4" | "t5" | "t6" | "t7" | "t8" | "t9") | 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" | "t10" | "t11" | "t12" | "t13" | "t14" | "t1a" | "t1b" | "t1c" | "t2" | "t3" | "t4" | "t5" | "t6" | "t7" | "t8" | "t9") | 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 transactionReplacement: {
+            readonly getKey: (transaction: {
+                from: import("viem").Address;
+                hash: `0x${string}`;
+                nonce: number;
+            }) => string;
+            readonly getReason: ({ replaced, replacement }: {
+                replaced: {
+                    from: import("viem").Address;
+                    hash: `0x${string}`;
+                    nonce: number;
+                };
+                replacement: {
+                    from: import("viem").Address;
+                    hash: `0x${string}`;
+                    nonce: number;
+                };
+            }) => import("viem").ReplacementReason;
+        };
+        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" | "t10" | "t11" | "t12" | "t13" | "t14" | "t1a" | "t1b" | "t1c" | "t2" | "t3" | "t4" | "t5" | "t6" | "t7" | "t8" | "t9") | 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}`>;
+    };
+    transactionReplacement: {
+        readonly getKey: (transaction: {
+            from: import("viem").Address;
+            hash: `0x${string}`;
+            nonce: number;
+        }) => string;
+        readonly getReason: ({ replaced, replacement }: {
+            replaced: {
+                from: import("viem").Address;
+                hash: `0x${string}`;
+                nonce: number;
+            };
+            replacement: {
+                from: import("viem").Address;
+                hash: `0x${string}`;
+                nonce: number;
+            };
+        }) => import("viem").ReplacementReason;
+    };
+    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" | "t10" | "t11" | "t12" | "t13" | "t14" | "t1a" | "t1b" | "t1c" | "t2" | "t3" | "t4" | "t5" | "t6" | "t7" | "t8" | "t9") | 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" | "t10" | "t11" | "t12" | "t13" | "t14" | "t1a" | "t1b" | "t1c" | "t2" | "t3" | "t4" | "t5" | "t6" | "t7" | "t8" | "t9") | 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 transactionReplacement: {
+            readonly getKey: (transaction: {
+                from: import("viem").Address;
+                hash: `0x${string}`;
+                nonce: number;
+            }) => string;
+            readonly getReason: ({ replaced, replacement }: {
+                replaced: {
+                    from: import("viem").Address;
+                    hash: `0x${string}`;
+                    nonce: number;
+                };
+                replacement: {
+                    from: import("viem").Address;
+                    hash: `0x${string}`;
+                    nonce: number;
+                };
+            }) => import("viem").ReplacementReason;
+        };
+        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.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" | "t10" | "t11" | "t12" | "t13" | "t14" | "t1a" | "t1b" | "t1c" | "t2" | "t3" | "t4" | "t5" | "t6" | "t7" | "t8" | "t9") | 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}`>;
+    };
+    transactionReplacement: {
+        readonly getKey: (transaction: {
+            from: import("viem").Address;
+            hash: `0x${string}`;
+            nonce: number;
+        }) => string;
+        readonly getReason: ({ replaced, replacement }: {
+            replaced: {
+                from: import("viem").Address;
+                hash: `0x${string}`;
+                nonce: number;
+            };
+            replacement: {
+                from: import("viem").Address;
+                hash: `0x${string}`;
+                nonce: number;
+            };
+        }) => import("viem").ReplacementReason;
+    };
+    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" | "t10" | "t11" | "t12" | "t13" | "t14" | "t1a" | "t1b" | "t1c" | "t2" | "t3" | "t4" | "t5" | "t6" | "t7" | "t8" | "t9") | 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" | "t10" | "t11" | "t12" | "t13" | "t14" | "t1a" | "t1b" | "t1c" | "t2" | "t3" | "t4" | "t5" | "t6" | "t7" | "t8" | "t9") | 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 transactionReplacement: {
+            readonly getKey: (transaction: {
+                from: import("viem").Address;
+                hash: `0x${string}`;
+                nonce: number;
+            }) => string;
+            readonly getReason: ({ replaced, replacement }: {
+                replaced: {
+                    from: import("viem").Address;
+                    hash: `0x${string}`;
+                    nonce: number;
+                };
+                replacement: {
+                    from: import("viem").Address;
+                    hash: `0x${string}`;
+                    nonce: number;
+                };
+            }) => import("viem").ReplacementReason;
+        };
+        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" | "t10" | "t11" | "t12" | "t13" | "t14" | "t1a" | "t1b" | "t1c" | "t2" | "t3" | "t4" | "t5" | "t6" | "t7" | "t8" | "t9") | 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}`>;
+    };
+    transactionReplacement: {
+        readonly getKey: (transaction: {
+            from: import("viem").Address;
+            hash: `0x${string}`;
+            nonce: number;
+        }) => string;
+        readonly getReason: ({ replaced, replacement }: {
+            replaced: {
+                from: import("viem").Address;
+                hash: `0x${string}`;
+                nonce: number;
+            };
+            replacement: {
+                from: import("viem").Address;
+                hash: `0x${string}`;
+                nonce: number;
+            };
+        }) => import("viem").ReplacementReason;
+    };
+    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" | "t10" | "t11" | "t12" | "t13" | "t14" | "t1a" | "t1b" | "t1c" | "t2" | "t3" | "t4" | "t5" | "t6" | "t7" | "t8" | "t9") | 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" | "t10" | "t11" | "t12" | "t13" | "t14" | "t1a" | "t1b" | "t1c" | "t2" | "t3" | "t4" | "t5" | "t6" | "t7" | "t8" | "t9") | 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 transactionReplacement: {
+            readonly getKey: (transaction: {
+                from: import("viem").Address;
+                hash: `0x${string}`;
+                nonce: number;
+            }) => string;
+            readonly getReason: ({ replaced, replacement }: {
+                replaced: {
+                    from: import("viem").Address;
+                    hash: `0x${string}`;
+                    nonce: number;
+                };
+                replacement: {
+                    from: import("viem").Address;
+                    hash: `0x${string}`;
+                    nonce: number;
+                };
+            }) => import("viem").ReplacementReason;
+        };
+        readonly verifyHash: (client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<boolean>;
+    }>, extended_1>;
+}];
+/** The default chain of a key: Tempo mainnet. */
+export declare const defaultChainId: 4217;
+/** Returns `key` with the EIP-191 hash of `challenge` as its witness, or 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 from its backend. */
+        challenge: string | undefined;
+    };
+}
+/**
+ * Returns the refusal for a `key` that breaks the rules of every flow, or `undefined`. Its `field`
+ * is a path under `key_authorization`.
+ */
+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];
+}
+/** Returns `ChallengeNotPermittedError` if `key` has a witness that the app may not bind. */
+export declare function checkChallenge(options: checkChallenge.Options): ErrorResponse.Instance<typeof checkChallenge.errors> | undefined;
+export declare namespace checkChallenge {
+    type Options = {
+        /** The app, or `undefined` when no app has `clientId`. */
+        app: Pick<Apps.App, 'sign'> | undefined;
+        /** The requesting app's client ID. */
+        clientId: string;
+        /** A key without a `witness`, or no key, passes. */
+        key: Key | undefined;
+    };
+    /** The refusals `checkChallenge` returns. */
+    const errors: readonly [typeof ChallengeNotPermittedError];
+}
+/**
+ * Returns `MissingPermissionsError` when a third-party app's raw request `sent` leaves out
+ * `expiry`, `limits`, or `scopes`, else `undefined`. A third-party app receives no defaults.
+ */
+export declare function checkExplicit(sent: unknown): ErrorResponse.Instance<typeof checkExplicit.errors> | undefined;
+export declare namespace checkExplicit {
+    /** The refusals `checkExplicit` returns. Its return type admits no other. */
+    const errors: readonly [typeof MissingPermissionsError];
+}
+/** Returns the refusal for `key` in a flow without a page, from `check` or the headless ceiling. */
+export declare function checkHeadless(key: Key, options: checkHeadless.Options): ErrorResponse.Instance<typeof checkHeadless.errors> | undefined;
+export declare namespace checkHeadless {
+    type Options = {
+        /** Whether the app holds `tempo-id:sign`, which permits unrecognized calls. */
+        sign: boolean;
+    };
+    /** 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];
+}
+/** Returns what a `key` that passes `check` grants, with limits totaled per currency and period. */
+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 the account's owner signs for `key`, which is a passkey's WebAuthn
+ * challenge. An owner's digest binds no account, so it is known before the passkey is. `witness`
+ * replaces the key's own. For a configurable account, each owner signs its configuration's digest.
+ */
+export declare function digest(options: digest.Options): `0x${string}`;
+export declare namespace digest {
+    type Options = {
+        /** The configurable account that the key acts for. Absent, the owner key is the account. */
+        account?: Account.ConfigurableAccount<AccountConfig.Config> | undefined;
+        /** The key authorization to commit to. */
+        key: Key;
+        /** Replaces the key's own witness, as a sign-in with key signature binds it. */
+        witness?: Hex.Hex | undefined;
+    };
+}
+/** Returns the access key's address, or the address of its `publicKey`. */
+export declare function keyId(key: Key): `0x${string}`;
+/** Returns the listed tokens on the chain with `chainId`. */
+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 it in the node's RPC format. A
+ * configurable account signs through one of its owners, and its authorization binds the account.
+ */
+export declare function sign(owner: Parameters<typeof Account.signKeyAuthorization>[0], options: sign.Options): Promise<KeyAuthorization.Rpc>;
+export declare namespace sign {
+    type Options = {
+        /** A key authorization that `check` accepts. */
+        key: Key;
+    };
+}
+/**
+ * Signs `key` with a verified passkey `assertion` over its {@link digest}, in the RPC format. For a
+ * configurable account, the assertion is the passkey owner's approval in the account's envelope.
+ */
+export declare function signWithAssertion(assertion: Passkey.Assertion, options: signWithAssertion.Options): Promise<KeyAuthorization.Rpc>;
+export declare namespace signWithAssertion {
+    type Options = {
+        /**
+         * The configurable account that the key acts for, on the chain where it is configurable. Absent,
+         * the passkey itself acts as the account.
+         */
+        account?: Account.ConfigurableAccount<AccountConfig.Config> | undefined;
+        /** The key authorization that the assertion signs. */
+        key: Key;
+        /** The passkey's uncompressed P256 public key. */
+        publicKey: Hex.Hex;
+    };
+}
+/** Whether `address` has the full 12-byte TIP-20 prefix, which no other contract shares. */
+export declare function tip20(address: string): boolean;
+export {};
+//# sourceMappingURL=KeyAuthorization.d.ts.map