import { type Context } from 'hono';
import * as z from 'zod/mini';
import type * as App from '../../../App.js';
import * as Response from '../../../internal/Response.js';
import * as VerifiedTokens from '../../../internal/VerifiedTokens.js';
import * as FxOracle from '../FxOracle.js';
/** Zod schemas owned by the valuation handlers. */
export declare namespace schema {
    /** A holding's nominal value in the requested denomination. */
    const Value: z.ZodMiniObject<{
        amount: z.ZodMiniString<string>;
        currency: z.ZodMiniString<string>;
    }, z.core.$strip>;
    /** Rate provenance for a converted valuation. */
    const Pricing: z.ZodMiniObject<{
        asOf: z.ZodMiniISODateTime;
        basis: z.ZodMiniLiteral<"nominal">;
        source: z.ZodMiniString<string>;
    }, z.core.$strip>;
    /** Schemas for the getAddressValuation operation. */
    namespace getAddressValuation {
        /** Path parameters for address valuation requests. */
        const Params: z.ZodMiniObject<{
            address: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
        }, z.core.$strip>;
        /** Query parameters for address valuation requests. */
        const Query: z.ZodMiniObject<{
            chainId: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniEnum<{
                mainnet: "mainnet";
                testnet: "testnet";
            }>, z.ZodMiniTransform<4217 | 42431, "mainnet" | "testnet">>, z.ZodMiniPipe<z.ZodMiniNumber<unknown>, z.ZodMiniTransform<number, number>>]>, z.ZodMiniNumber<number>>>;
            currency: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<string, string>>>;
        }, z.core.$strict>;
        /** The nominal valuation of an account's verified holdings. */
        const Response: z.ZodMiniObject<{
            address: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
            amount: z.ZodMiniString<string>;
            currency: z.ZodMiniString<string>;
            id: z.ZodMiniString<string>;
            pricing: z.ZodMiniNullable<z.ZodMiniObject<{
                asOf: z.ZodMiniISODateTime;
                basis: z.ZodMiniLiteral<"nominal">;
                source: z.ZodMiniString<string>;
            }, z.core.$strip>>;
            unpriced: z.ZodMiniArray<z.ZodMiniString<string>>;
        }, z.core.$strip>;
    }
}
/**
 * Creates address-scoped valuation handlers, mounted under the `/addresses`
 * composer. Exposes `GET /:address/valuation`, the holdings valuation.
 */
export declare function addresses(options?: addresses.Options): import("hono/hono-base").HonoBase<App.Environment, {
    "/v1/addresses/:address/valuation": {
        $get: {
            output: null;
            outputFormat: "body";
            status: 402;
            input: {
                param: {
                    address: `0x${string}`;
                };
            } & {
                query?: {
                    chainId?: string | string[];
                    currency?: string | string[];
                } | undefined;
            };
        } | {
            output: {
                error: {
                    code: "upstream_error";
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 502;
            input: {
                param: {
                    address: `0x${string}`;
                };
            } & {
                query?: {
                    chainId?: string | string[];
                    currency?: string | string[];
                } | undefined;
            };
        } | {
            output: {
                error: {
                    code: "query_invalid";
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 400;
            input: {
                param: {
                    address: `0x${string}`;
                };
            } & {
                query?: {
                    chainId?: string | string[];
                    currency?: string | string[];
                } | undefined;
            };
        } | {
            output: {
                error: {
                    code: "api_key_malformed";
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 400;
            input: {
                param: {
                    address: `0x${string}`;
                };
            } & {
                query?: {
                    chainId?: string | string[];
                    currency?: string | string[];
                } | undefined;
            };
        } | {
            output: {
                error: {
                    code: "api_key_invalid" | "api_key_missing";
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 401;
            input: {
                param: {
                    address: `0x${string}`;
                };
            } & {
                query?: {
                    chainId?: string | string[];
                    currency?: string | string[];
                } | undefined;
            };
        } | {
            output: {
                error: {
                    code: "api_key_forbidden" | "api_key_ip_forbidden";
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 403;
            input: {
                param: {
                    address: `0x${string}`;
                };
            } & {
                query?: {
                    chainId?: string | string[];
                    currency?: string | string[];
                } | undefined;
            };
        } | {
            output: {
                error: {
                    code: "payment_required" | "rate_limit_exceeded";
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 429;
            input: {
                param: {
                    address: `0x${string}`;
                };
            } & {
                query?: {
                    chainId?: string | string[];
                    currency?: string | string[];
                } | undefined;
            };
        } | {
            output: {
                error: {
                    code: "address_invalid";
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 400;
            input: {
                param: {
                    address: `0x${string}`;
                };
            } & {
                query?: {
                    chainId?: string | string[];
                    currency?: string | string[];
                } | undefined;
            };
        } | {
            output: {
                address: `0x${string}`;
                amount: string;
                currency: string;
                id: string;
                pricing: {
                    asOf: string;
                    basis: "nominal";
                    source: string;
                } | null;
                unpriced: string[];
            };
            outputFormat: "json";
            status: 200;
            input: {
                param: {
                    address: `0x${string}`;
                };
            } & {
                query?: {
                    chainId?: string | string[];
                    currency?: string | string[];
                } | undefined;
            };
        };
    };
}, "/", "/v1/addresses/:address/valuation">;
export declare namespace addresses {
    /** Options for the address-scoped valuation handlers. */
    type Options = {
        /** FX configuration backing currency conversion. */
        fx?: Fx | undefined;
    };
    /** FX configuration for valuation handlers. */
    type Fx = {
        /** FX rate oracle. Defaults to `FxOracle.ecb()`. */
        oracle?: FxOracle.Oracle | undefined;
    };
}
/** Loads the oracle's rate set through the request's store cache. */
export declare function rateSet(c: Context<App.Environment>, oracle: FxOracle.Oracle): Promise<FxOracle.RateSet>;
/**
 * Loads rates best-effort to validate the denomination and value a page.
 * Returns `undefined` when unavailable or unnecessary; a known unsupported denomination still throws.
 */
export declare function ratesFor(c: Context<App.Environment>, options: ratesFor.Options): Promise<FxOracle.RateSet | undefined>;
export declare namespace ratesFor {
    /** Options for loading a page's valuation rates. */
    type Options = {
        /** Display currencies of the curated holdings appearing on the page. */
        currencies: Iterable<string>;
        /** Currency values are denominated in (uppercase). */
        denomination: string;
        /** FX rate oracle backing currency conversion. */
        oracle: FxOracle.Oracle;
    };
}
/** Builds the `pricing` provenance block for a consulted rate set. */
export declare function pricing(rates: FxOracle.RateSet, oracle: FxOracle.Oracle): {
    asOf: string;
    basis: 'nominal';
    source: string;
};
/**
 * Values one holding in the requested denomination via its curated display
 * currency. Returns `null` when the token is unverified, its currency has no
 * rate, or the rate set is unavailable.
 */
export declare function valuationFor(options: valuationFor.Options): {
    amount: string;
    currency: string;
} | null;
export declare namespace valuationFor {
    /** Options for valuing one holding. */
    type Options = {
        /** Holding amount in the token's base units. */
        amount: bigint;
        /** Currency the value is denominated in (uppercase). */
        denomination: string;
        /** Oracle rate set, when loaded. */
        rates: FxOracle.RateSet | undefined;
        /** Display currency and decimal scale backing the holding, when known. */
        token: Pick<VerifiedTokens.Snapshot['list'][number], 'currency' | 'decimals'> | undefined;
    };
}
/** Thrown when the requested denomination is not priced by the FX oracle. */
export declare class UnsupportedDenominationError extends Error {
    name: string;
    constructor(denomination: string, oracle: string);
}
//# sourceMappingURL=valuation.d.ts.map