/**
 * @module plugin/magicblock/schemas
 * @description Zod schemas for every MagicBlock plugin tool.
 *
 * Each schema is an `{ input, output }` pair that drives:
 *   1. Runtime validation (LLM → tool call)
 *   2. LangChain StructuredTool generation
 *   3. MCP / Vercel AI tool descriptors
 *
 * Conventions (mirrors the SAP plugin — keep them identical):
 *   - Solana public keys → `z.string().min(32).max(44)`
 *   - Token amounts      → `z.string()` (base-unit, BN-safe)
 *   - Transaction output → `{ transactionBase64, sendTo, ... }` (unsigned tx)
 *   - Read output        → typed object matching the API response
 *
 * Three protocol domains:
 *   - mb-router    — ER Router JSON-RPC (6 tools, read-only)
 *   - mb-payments  — Private Payment API REST (12 tools, mixed read/write)
 *   - mb-vrf       — Solana VRF (2 tools, SDK-based)
 *
 * @category Plugin
 * @since v0.1.0
 */
import { z } from "zod";
/**
 * Zod input/output schemas for the **mb-router** protocol (6 tools).
 *
 * @name routerSchemas
 * @description Covers getRoutes, getIdentity, getDelegationStatus,
 *   getAccountInfo, getBlockhashForAccounts, and getSignatureStatuses.
 *   All are read-only JSON-RPC calls to the MagicBlock Router.
 * @category Plugin
 * @since v0.1.0
 */
export declare const routerSchemas: {
    readonly getRoutes: {
        readonly input: z.ZodObject<{
            endpoint: z.ZodDefault<z.ZodEnum<{
                devnet: "devnet";
                mainnet: "mainnet";
            }>>;
        }, z.core.$strip>;
        readonly output: z.ZodObject<{
            routes: z.ZodArray<z.ZodObject<{
                identity: z.ZodString;
                fqdn: z.ZodString;
                baseFee: z.ZodNumber;
                blockTimeMs: z.ZodNumber;
                countryCode: z.ZodString;
            }, z.core.$strip>>;
        }, z.core.$strip>;
    };
    readonly getIdentity: {
        readonly input: z.ZodObject<{
            endpoint: z.ZodDefault<z.ZodEnum<{
                devnet: "devnet";
                mainnet: "mainnet";
            }>>;
        }, z.core.$strip>;
        readonly output: z.ZodObject<{
            identity: z.ZodString;
            fqdn: z.ZodString;
        }, z.core.$strip>;
    };
    readonly getDelegationStatus: {
        readonly input: z.ZodObject<{
            account: z.ZodString;
            endpoint: z.ZodDefault<z.ZodEnum<{
                devnet: "devnet";
                mainnet: "mainnet";
            }>>;
        }, z.core.$strip>;
        readonly output: z.ZodObject<{
            isDelegated: z.ZodBoolean;
            fqdn: z.ZodOptional<z.ZodNullable<z.ZodString>>;
            delegationRecord: z.ZodOptional<z.ZodNullable<z.ZodObject<{
                authority: z.ZodString;
                owner: z.ZodString;
                delegationSlot: z.ZodNumber;
                lamports: z.ZodNumber;
            }, z.core.$strip>>>;
        }, z.core.$strip>;
    };
    readonly getAccountInfo: {
        readonly input: z.ZodObject<{
            account: z.ZodString;
            encoding: z.ZodDefault<z.ZodEnum<{
                base64: "base64";
                "base64+zstd": "base64+zstd";
            }>>;
            endpoint: z.ZodDefault<z.ZodEnum<{
                devnet: "devnet";
                mainnet: "mainnet";
            }>>;
        }, z.core.$strip>;
        readonly output: z.ZodObject<{
            context: z.ZodObject<{
                apiVersion: z.ZodString;
                slot: z.ZodNumber;
            }, z.core.$strip>;
            value: z.ZodObject<{
                data: z.ZodArray<z.ZodString>;
                executable: z.ZodBoolean;
                lamports: z.ZodNumber;
                owner: z.ZodString;
                rentEpoch: z.ZodString;
                space: z.ZodNumber;
            }, z.core.$strip>;
        }, z.core.$strip>;
    };
    readonly getBlockhashForAccounts: {
        readonly input: z.ZodObject<{
            accounts: z.ZodArray<z.ZodString>;
            endpoint: z.ZodDefault<z.ZodEnum<{
                devnet: "devnet";
                mainnet: "mainnet";
            }>>;
        }, z.core.$strip>;
        readonly output: z.ZodObject<{
            blockhash: z.ZodString;
            lastValidBlockHeight: z.ZodNumber;
        }, z.core.$strip>;
    };
    readonly getSignatureStatuses: {
        readonly input: z.ZodObject<{
            signatures: z.ZodArray<z.ZodString>;
            endpoint: z.ZodDefault<z.ZodEnum<{
                devnet: "devnet";
                mainnet: "mainnet";
            }>>;
        }, z.core.$strip>;
        readonly output: z.ZodObject<{
            context: z.ZodObject<{
                apiVersion: z.ZodString;
                slot: z.ZodNumber;
            }, z.core.$strip>;
            statuses: z.ZodArray<z.ZodObject<{
                confirmationStatus: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
                    processed: "processed";
                    confirmed: "confirmed";
                    finalized: "finalized";
                }>>>;
                confirmations: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
                err: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
                slot: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
            }, z.core.$strip>>;
        }, z.core.$strip>;
    };
};
/**
 * Zod input/output schemas for the **mb-payments** protocol (12 tools).
 *
 * @name paymentsSchemas
 * @description Covers health, challenge, login, balance, private-balance,
 *   deposit, transfer, withdraw, swap-quote, swap, initialize-mint,
 *   and is-mint-initialized — all REST calls to the Private Payment API.
 * @category Plugin
 * @since v0.1.0
 */
export declare const paymentsSchemas: {
    readonly health: {
        readonly input: z.ZodObject<{}, z.core.$strip>;
        readonly output: z.ZodObject<{
            status: z.ZodLiteral<"ok">;
        }, z.core.$strip>;
    };
    readonly challenge: {
        readonly input: z.ZodObject<{
            pubkey: z.ZodString;
            cluster: z.ZodOptional<z.ZodNullable<z.ZodString>>;
            mock: z.ZodDefault<z.ZodBoolean>;
        }, z.core.$strip>;
        readonly output: z.ZodObject<{
            challenge: z.ZodString;
        }, z.core.$strip>;
    };
    readonly login: {
        readonly input: z.ZodObject<{
            pubkey: z.ZodString;
            challenge: z.ZodString;
            signature: z.ZodString;
            cluster: z.ZodOptional<z.ZodNullable<z.ZodString>>;
            mock: z.ZodDefault<z.ZodBoolean>;
        }, z.core.$strip>;
        readonly output: z.ZodObject<{
            token: z.ZodString;
        }, z.core.$strip>;
    };
    readonly balance: {
        readonly input: z.ZodObject<{
            address: z.ZodString;
            mint: z.ZodString;
            cluster: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        }, z.core.$strip>;
        readonly output: z.ZodObject<{
            address: z.ZodString;
            mint: z.ZodString;
            ata: z.ZodString;
            location: z.ZodEnum<{
                base: "base";
                ephemeral: "ephemeral";
            }>;
            balance: z.ZodString;
        }, z.core.$strip>;
    };
    readonly privateBalance: {
        readonly input: z.ZodObject<{
            address: z.ZodString;
            mint: z.ZodString;
            cluster: z.ZodOptional<z.ZodNullable<z.ZodString>>;
            authToken: z.ZodString;
        }, z.core.$strip>;
        readonly output: z.ZodObject<{
            address: z.ZodString;
            mint: z.ZodString;
            ata: z.ZodString;
            location: z.ZodEnum<{
                base: "base";
                ephemeral: "ephemeral";
            }>;
            balance: z.ZodString;
        }, z.core.$strip>;
    };
    readonly deposit: {
        readonly input: z.ZodObject<{
            owner: z.ZodString;
            amount: z.ZodNumber;
            mint: z.ZodOptional<z.ZodNullable<z.ZodString>>;
            cluster: z.ZodOptional<z.ZodNullable<z.ZodString>>;
            validator: z.ZodOptional<z.ZodNullable<z.ZodString>>;
            initIfMissing: z.ZodDefault<z.ZodBoolean>;
            initVaultIfMissing: z.ZodDefault<z.ZodBoolean>;
            initAtasIfMissing: z.ZodDefault<z.ZodBoolean>;
            idempotent: z.ZodDefault<z.ZodBoolean>;
        }, z.core.$strip>;
        readonly output: z.ZodObject<{
            kind: z.ZodString;
            version: z.ZodEnum<{
                legacy: "legacy";
                v0: "v0";
            }>;
            transactionBase64: z.ZodString;
            sendTo: z.ZodEnum<{
                base: "base";
                ephemeral: "ephemeral";
            }>;
            recentBlockhash: z.ZodString;
            lastValidBlockHeight: z.ZodNumber;
            instructionCount: z.ZodNumber;
            requiredSigners: z.ZodArray<z.ZodString>;
            validator: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        }, z.core.$strip>;
    };
    readonly transfer: {
        readonly input: z.ZodObject<{
            from: z.ZodString;
            to: z.ZodString;
            mint: z.ZodString;
            amount: z.ZodNumber;
            visibility: z.ZodEnum<{
                public: "public";
                private: "private";
            }>;
            fromBalance: z.ZodEnum<{
                base: "base";
                ephemeral: "ephemeral";
            }>;
            toBalance: z.ZodEnum<{
                base: "base";
                ephemeral: "ephemeral";
            }>;
            cluster: z.ZodOptional<z.ZodNullable<z.ZodString>>;
            validator: z.ZodOptional<z.ZodNullable<z.ZodString>>;
            authToken: z.ZodOptional<z.ZodNullable<z.ZodString>>;
            initIfMissing: z.ZodDefault<z.ZodBoolean>;
            initAtasIfMissing: z.ZodDefault<z.ZodBoolean>;
            initVaultIfMissing: z.ZodDefault<z.ZodBoolean>;
            memo: z.ZodOptional<z.ZodNullable<z.ZodString>>;
            minDelayMs: z.ZodOptional<z.ZodNullable<z.ZodString>>;
            maxDelayMs: z.ZodOptional<z.ZodNullable<z.ZodString>>;
            clientRefId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
            split: z.ZodDefault<z.ZodNumber>;
            gasless: z.ZodDefault<z.ZodBoolean>;
            legacy: z.ZodDefault<z.ZodBoolean>;
        }, z.core.$strip>;
        readonly output: z.ZodObject<{
            kind: z.ZodString;
            version: z.ZodEnum<{
                legacy: "legacy";
                v0: "v0";
            }>;
            transactionBase64: z.ZodString;
            sendTo: z.ZodEnum<{
                base: "base";
                ephemeral: "ephemeral";
            }>;
            recentBlockhash: z.ZodString;
            lastValidBlockHeight: z.ZodNumber;
            instructionCount: z.ZodNumber;
            requiredSigners: z.ZodArray<z.ZodString>;
            validator: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        }, z.core.$strip>;
    };
    readonly withdraw: {
        readonly input: z.ZodObject<{
            owner: z.ZodString;
            mint: z.ZodString;
            amount: z.ZodNumber;
            cluster: z.ZodOptional<z.ZodNullable<z.ZodString>>;
            validator: z.ZodOptional<z.ZodNullable<z.ZodString>>;
            initIfMissing: z.ZodDefault<z.ZodBoolean>;
            initAtasIfMissing: z.ZodDefault<z.ZodBoolean>;
            escrowIndex: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
            idempotent: z.ZodDefault<z.ZodBoolean>;
        }, z.core.$strip>;
        readonly output: z.ZodObject<{
            kind: z.ZodString;
            version: z.ZodEnum<{
                legacy: "legacy";
                v0: "v0";
            }>;
            transactionBase64: z.ZodString;
            sendTo: z.ZodEnum<{
                base: "base";
                ephemeral: "ephemeral";
            }>;
            recentBlockhash: z.ZodString;
            lastValidBlockHeight: z.ZodNumber;
            instructionCount: z.ZodNumber;
            requiredSigners: z.ZodArray<z.ZodString>;
            validator: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        }, z.core.$strip>;
    };
    readonly swapQuote: {
        readonly input: z.ZodObject<{
            inputMint: z.ZodString;
            outputMint: z.ZodString;
            amount: z.ZodString;
            slippageBps: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
            swapMode: z.ZodDefault<z.ZodEnum<{
                ExactIn: "ExactIn";
                ExactOut: "ExactOut";
            }>>;
            onlyDirectRoutes: z.ZodDefault<z.ZodBoolean>;
            restrictIntermediateTokens: z.ZodDefault<z.ZodBoolean>;
            platformFeeBps: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
            maxAccounts: z.ZodDefault<z.ZodNumber>;
        }, z.core.$strip>;
        readonly output: z.ZodObject<{
            inputMint: z.ZodString;
            inAmount: z.ZodString;
            outputMint: z.ZodString;
            outAmount: z.ZodString;
            otherAmountThreshold: z.ZodString;
            swapMode: z.ZodEnum<{
                ExactIn: "ExactIn";
                ExactOut: "ExactOut";
            }>;
            slippageBps: z.ZodNumber;
            priceImpactPct: z.ZodString;
            routePlan: z.ZodArray<z.ZodObject<{
                swapInfo: z.ZodObject<{
                    ammKey: z.ZodString;
                    label: z.ZodString;
                    inputMint: z.ZodString;
                    outputMint: z.ZodString;
                    inAmount: z.ZodString;
                    outAmount: z.ZodString;
                }, z.core.$strip>;
                percent: z.ZodNumber;
                bps: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
            }, z.core.$strip>>;
            contextSlot: z.ZodNumber;
            timeTaken: z.ZodNumber;
        }, z.core.$strip>;
    };
    readonly swap: {
        readonly input: z.ZodObject<{
            userPublicKey: z.ZodString;
            quoteResponse: z.ZodRecord<z.ZodString, z.ZodUnknown>;
            visibility: z.ZodDefault<z.ZodEnum<{
                public: "public";
                private: "private";
            }>>;
            destination: z.ZodOptional<z.ZodNullable<z.ZodString>>;
            minDelayMs: z.ZodOptional<z.ZodNullable<z.ZodString>>;
            maxDelayMs: z.ZodOptional<z.ZodNullable<z.ZodString>>;
            split: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
            clientRefId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
            validator: z.ZodOptional<z.ZodNullable<z.ZodString>>;
            wrapAndUnwrapSol: z.ZodDefault<z.ZodBoolean>;
            asLegacyTransaction: z.ZodDefault<z.ZodBoolean>;
        }, z.core.$strip>;
        readonly output: z.ZodObject<{
            swapTransaction: z.ZodString;
            lastValidBlockHeight: z.ZodNumber;
            prioritizationFeeLamports: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
            privateTransfer: z.ZodOptional<z.ZodNullable<z.ZodObject<{
                stashAta: z.ZodString;
                hydraCrankPda: z.ZodString;
                shuttleId: z.ZodNumber;
            }, z.core.$strip>>>;
        }, z.core.$strip>;
    };
    readonly initializeMint: {
        readonly input: z.ZodObject<{
            owner: z.ZodString;
            mint: z.ZodString;
            cluster: z.ZodOptional<z.ZodNullable<z.ZodString>>;
            validator: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        }, z.core.$strip>;
        readonly output: z.ZodObject<{
            kind: z.ZodString;
            version: z.ZodEnum<{
                legacy: "legacy";
                v0: "v0";
            }>;
            transactionBase64: z.ZodString;
            sendTo: z.ZodEnum<{
                base: "base";
                ephemeral: "ephemeral";
            }>;
            recentBlockhash: z.ZodString;
            lastValidBlockHeight: z.ZodNumber;
            instructionCount: z.ZodNumber;
            requiredSigners: z.ZodArray<z.ZodString>;
            validator: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        }, z.core.$strip>;
    };
    readonly isMintInitialized: {
        readonly input: z.ZodObject<{
            mint: z.ZodString;
            cluster: z.ZodOptional<z.ZodNullable<z.ZodString>>;
            validator: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        }, z.core.$strip>;
        readonly output: z.ZodObject<{
            initialized: z.ZodBoolean;
        }, z.core.$strip>;
    };
};
/**
 * Zod input/output schemas for the **mb-vrf** protocol (2 tools).
 *
 * @name vrfSchemas
 * @description Covers VRF randomness request and result retrieval.
 *   These are SDK-based and will be implemented when the VRF SDK
 *   is available as an npm dependency.
 * @category Plugin
 * @since v0.1.0
 */
export declare const vrfSchemas: {
    readonly requestRandomness: {
        readonly input: z.ZodObject<{
            callerSeed: z.ZodString;
            callbackDiscriminator: z.ZodString;
            callbackAccounts: z.ZodArray<z.ZodString>;
            endpoint: z.ZodDefault<z.ZodEnum<{
                devnet: "devnet";
                mainnet: "mainnet";
            }>>;
        }, z.core.$strip>;
        readonly output: z.ZodObject<{
            requestKey: z.ZodString;
            txSignature: z.ZodString;
        }, z.core.$strip>;
    };
    readonly getRandomnessResult: {
        readonly input: z.ZodObject<{
            requestKey: z.ZodString;
            endpoint: z.ZodDefault<z.ZodEnum<{
                devnet: "devnet";
                mainnet: "mainnet";
            }>>;
        }, z.core.$strip>;
        readonly output: z.ZodObject<{
            fulfilled: z.ZodBoolean;
            randomBytes: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber>>>;
            proof: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber>>>;
        }, z.core.$strip>;
    };
};
//# sourceMappingURL=schemas.d.ts.map