import type { Address, Chain } from 'viem';
import * as z from 'zod/mini';
import * as Viem from './Viem.js';
/** Zod schemas owned by the Earn vault resolver. */
export declare namespace schema {
    /** Schema selecting one onchain Earn vault. */
    const ResolveInput: z.ZodMiniObject<{
        chainId: 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>>;
        vaultAddress: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
    }, z.core.$strict>;
    /** Schema for one curated Earn route through a private Zone. */
    const ZoneRoute: z.ZodMiniObject<{
        chainId: 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>>;
        deploymentBlock: z.ZodMiniNumber<number>;
        earnRouter: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
    }, z.core.$strict>;
    /** Schema for live state resolved from one Earn vault. */
    const Discovery: z.ZodMiniObject<{
        access: z.ZodMiniOptional<z.ZodMiniObject<{
            status: z.ZodMiniEnum<{
                allowlisted: "allowlisted";
                open: "open";
            }>;
        }, z.core.$strict>>;
        assetToken: z.ZodMiniObject<{
            address: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
            currency: z.ZodMiniString<string>;
            decimals: z.ZodMiniNumber<number>;
            name: z.ZodMiniString<string>;
            symbol: z.ZodMiniString<string>;
        }, z.core.$strict>;
        capabilities: z.ZodMiniOptional<z.ZodMiniObject<{
            asyncRedeem: z.ZodMiniBoolean<boolean>;
            boundedRedeem: z.ZodMiniBoolean<boolean>;
            deposit: z.ZodMiniBoolean<boolean>;
            exactWithdraw: z.ZodMiniBoolean<boolean>;
            inKindDeposit: z.ZodMiniBoolean<boolean>;
            privateRouting: z.ZodMiniBoolean<boolean>;
            redeem: z.ZodMiniBoolean<boolean>;
            routerSwaps: z.ZodMiniBoolean<boolean>;
        }, z.core.$strict>>;
        chainId: 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>>;
        engine: z.ZodMiniObject<{
            address: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
            type: z.ZodMiniNullable<z.ZodMiniEnum<{
                erc4626: "erc4626";
                veda: "veda";
            }>>;
            venue: z.ZodMiniNullable<z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>>;
        }, z.core.$strict>;
        instantLiquidity: z.ZodMiniNullable<z.ZodMiniString<string>>;
        sharePrice: z.ZodMiniNullable<z.ZodMiniString<string>>;
        shareToken: z.ZodMiniObject<{
            address: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
            currency: z.ZodMiniString<string>;
            decimals: z.ZodMiniNumber<number>;
            name: z.ZodMiniString<string>;
            symbol: z.ZodMiniString<string>;
        }, z.core.$strict>;
        state: z.ZodMiniObject<{
            depositsPaused: z.ZodMiniBoolean<boolean>;
            engineShares: z.ZodMiniString<string>;
            feesActive: z.ZodMiniBoolean<boolean>;
            isAccountingAligned: z.ZodMiniBoolean<boolean>;
            openRedeemRequestCount: z.ZodMiniNumber<number>;
            totalAssets: z.ZodMiniString<string>;
            totalEarnShares: z.ZodMiniString<string>;
        }, z.core.$strict>;
        vaultAddress: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
    }, z.core.$strict>;
}
/** Live state resolved from an Earn vault. */
export type Discovery = z.output<typeof schema.Discovery>;
/** Onchain identity of an Earn vault. */
export type ResolveInput = z.output<typeof schema.ResolveInput>;
/** Curated Earn route through one private Zone. */
export type ZoneRoute = z.output<typeof schema.ZoneRoute>;
/** Curated Zone route with immutable router bindings resolved onchain. */
export type ResolvedZoneRoute = ZoneRoute & {
    /** Tokens accepted by private deposits. */
    inputTokens: readonly Address[];
    /** Configured private Zone name. */
    name: string;
    /** Tokens returned by private redemptions. */
    outputTokens: readonly Address[];
};
/** Adds capabilities proven by a verified private Zone route. */
export declare function addZoneRouteCapabilities(capabilities: NonNullable<Discovery['capabilities']>): NonNullable<Discovery['capabilities']>;
/** Derives a Zone ID from any supported Zone chain-ID scheme. */
export declare function deriveZoneId(chainId: number): number;
/** Stable code describing an onchain verification issue. */
export type VerificationIssueCode = 'chain-mismatch' | 'engine-asset-mismatch' | 'policy-unsupported' | 'read-failed' | 'zone-deployment-block-mismatch' | 'zone-flow-unsupported' | 'zone-id-mismatch' | 'zone-router-invalid' | 'zone-share-mismatch' | 'zone-vault-asset-mismatch' | 'zone-vault-mismatch';
/** One onchain verification issue. */
export type VerificationIssue = {
    /** Observed value, when available. */
    actual?: string | undefined;
    /** Stable machine-readable issue code. */
    code: VerificationIssueCode;
    /** Expected value, when available. */
    expected?: string | undefined;
    /** Human-readable issue detail. */
    message: string;
};
/** Token and vault state observed during verification. */
export type VerificationSnapshot = {
    /** Asset token observed onchain. */
    assetToken?: Discovery['assetToken'] | undefined;
    /** Whether vault supply matches its engine backing. */
    isSynced?: boolean | undefined;
    /** Share token observed onchain. */
    shareToken?: Discovery['shareToken'] | undefined;
};
type VerificationMismatch = {
    /** Issues found while reading the deployment. */
    issues: readonly VerificationIssue[];
    /** Token and vault state observed during verification. */
    snapshot: VerificationSnapshot;
    /** Indicates that onchain state is incompatible. */
    status: 'mismatch';
};
type VerificationUnavailable = {
    /** Issue that prevented verification. */
    issues: readonly VerificationIssue[];
    /** Indicates that verification could not complete. */
    status: 'unavailable';
};
type VerificationFailure = VerificationMismatch | VerificationUnavailable;
/** Resolves one Earn vault from its onchain identity. */
export declare function resolve(options: resolve.ProjectedOptions): Promise<Discovery>;
/** Resolves every optional Earn vault field. */
export declare function resolve(options: resolve.Options): Promise<resolve.CompleteDiscovery>;
export declare namespace resolve {
    /** Fully resolved Earn vault state. */
    type CompleteDiscovery = Discovery & {
        /** Vault share-token access. */
        access: NonNullable<Discovery['access']>;
        /** Actions supported by the vault. */
        capabilities: NonNullable<Discovery['capabilities']>;
    };
    /** Optional onchain fields to resolve. */
    type Include = 'access' | 'capabilities';
    /** Options for resolving one Earn vault. */
    type Options = {
        /** Resolves the onchain client used to read the vault. */
        getClient: Viem.GetClient;
        /** Chain and vault identity to resolve. */
        input: unknown;
        /** Private zones available to Earn routers. */
        zones: readonly Chain[];
    };
    /** Options for resolving selected optional fields. */
    type ProjectedOptions = Options & {
        /** Optional onchain fields to resolve. */
        include: readonly Include[];
    };
}
/** Resolves and verifies every curated Zone route for one Earn vault. */
export declare function resolveZoneRoutes(options: resolveZoneRoutes.Options): Promise<ResolvedZoneRoute[]>;
export declare namespace resolveZoneRoutes {
    /** Inputs for resolving and verifying curated Zone routes. */
    type Options = {
        /** Live state of the Earn vault bound by every router. */
        discovery: Discovery;
        /** Resolves the parent-chain client used to read each router. */
        getClient: Viem.GetClient;
        /** Curated Zone routes to verify. */
        routes: unknown;
        /** Private Zones configured by the API. */
        zones: readonly Chain[];
    };
}
/** Infers the supported engine type from its capability fingerprint. */
export declare function classifyEngineType(options: classifyEngineType.Options): classifyEngineType.ReturnType;
export declare namespace classifyEngineType {
    /** Capability fingerprint used to classify an engine. */
    type Options = {
        /** Whether queued redemptions are supported. */
        asyncRedeem: boolean;
        /** Whether venue-share deposits are supported. */
        inKindDeposit: boolean;
    };
    /** Supported engine type, or null for an unknown fingerprint. */
    type ReturnType = 'erc4626' | 'veda' | null;
}
/** Thrown when an Earn resolver value fails schema validation. */
export declare class InvalidRegistryError extends Error {
    name: string;
}
/** Thrown when a requested Earn vault does not exist. */
export declare class NotFoundError extends Error {
    name: string;
}
/** Thrown when onchain verification rejects an Earn vault. */
export declare class VerificationError extends Error {
    /** Failed verification result. */
    result: VerificationFailure;
    constructor(result: VerificationFailure);
    name: string;
}
export {};
//# sourceMappingURL=EarnVaults.d.ts.map