import * as z from 'zod/mini';
import * as Response from '../../internal/Response.js';
import type * as App from '../App.js';
/** Zod schemas owned by the admin verified-tokens handler. */
export declare namespace schema {
    /** A curated verified TIP-20 token entry (shared with the public read API). */
    const Token: z.ZodMiniObject<{
        address: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
        currency: z.ZodMiniString<string>;
        decimals: z.ZodMiniNumber<number>;
        logoUri: z.ZodMiniOptional<z.ZodMiniURL>;
        name: z.ZodMiniString<string>;
        symbol: z.ZodMiniString<string>;
        id: z.ZodMiniString<string>;
    }, z.core.$strip>;
    /** Verified-token write/input fields without the server-derived `id`. */
    const Input: z.ZodMiniObject<{
        address: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
        currency: z.ZodMiniString<string>;
        decimals: z.ZodMiniNumber<number>;
        logoUri: z.ZodMiniOptional<z.ZodMiniURL>;
        name: z.ZodMiniString<string>;
        symbol: z.ZodMiniString<string>;
    }, z.core.$strip>;
    /** Path parameters addressing a single verified token. */
    const Params: z.ZodMiniObject<{
        address: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
    }, z.core.$strip>;
    /** Schemas for the listVerifiedTokens operation. */
    namespace listVerifiedTokens {
        /** Query parameters for the verified-token list. */
        const Query: 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>>;
        }, z.core.$strict>;
        /** Response: the curated list and the current snapshot version. */
        const Response: z.ZodMiniObject<{
            data: z.ZodMiniArray<z.ZodMiniObject<{
                address: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
                currency: z.ZodMiniString<string>;
                decimals: z.ZodMiniNumber<number>;
                logoUri: z.ZodMiniOptional<z.ZodMiniURL>;
                name: z.ZodMiniString<string>;
                symbol: z.ZodMiniString<string>;
                id: z.ZodMiniString<string>;
            }, z.core.$strip>>;
            version: z.ZodMiniNullable<z.ZodMiniString<string>>;
        }, z.core.$strip>;
    }
    /** Schemas for the createVerifiedToken operation. */
    namespace createVerifiedToken {
        /** Request body for creating a verified token. */
        const Body: z.ZodMiniObject<{
            address: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
            currency: z.ZodMiniString<string>;
            decimals: z.ZodMiniNumber<number>;
            logoUri: z.ZodMiniOptional<z.ZodMiniURL>;
            name: z.ZodMiniString<string>;
            symbol: z.ZodMiniString<string>;
            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>>;
            logo: z.ZodMiniOptional<z.ZodMiniString<string>>;
        }, z.core.$strip>;
        /** Response after a successful create. */
        const Response: z.ZodMiniObject<{
            data: z.ZodMiniObject<{
                address: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
                currency: z.ZodMiniString<string>;
                decimals: z.ZodMiniNumber<number>;
                logoUri: z.ZodMiniOptional<z.ZodMiniURL>;
                name: z.ZodMiniString<string>;
                symbol: z.ZodMiniString<string>;
                id: z.ZodMiniString<string>;
            }, z.core.$strip>;
            version: z.ZodMiniString<string>;
        }, z.core.$strip>;
    }
    /** Schemas for the patchVerifiedToken operation. */
    namespace patchVerifiedToken {
        /** Query parameters for a verified-token patch. */
        const Query: 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>>;
        }, z.core.$strict>;
        /** Request body for partially updating a verified token. */
        const Body: z.ZodMiniObject<{
            currency: z.ZodMiniOptional<z.ZodMiniString<string>>;
            decimals: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
            logoUri: z.ZodMiniOptional<z.ZodMiniOptional<z.ZodMiniURL>>;
            name: z.ZodMiniOptional<z.ZodMiniString<string>>;
            symbol: z.ZodMiniOptional<z.ZodMiniString<string>>;
        }, z.core.$strip>;
        /** Response after a successful patch. */
        const Response: z.ZodMiniObject<{
            data: z.ZodMiniObject<{
                address: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
                currency: z.ZodMiniString<string>;
                decimals: z.ZodMiniNumber<number>;
                logoUri: z.ZodMiniOptional<z.ZodMiniURL>;
                name: z.ZodMiniString<string>;
                symbol: z.ZodMiniString<string>;
                id: z.ZodMiniString<string>;
            }, z.core.$strip>;
            version: z.ZodMiniString<string>;
        }, z.core.$strip>;
    }
    /** Schemas for the deleteVerifiedToken operation. */
    namespace deleteVerifiedToken {
        /** Query parameters for a verified-token delete. */
        const Query: 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>>;
        }, z.core.$strict>;
        /** Response after a successful delete. */
        const Response: z.ZodMiniObject<{
            version: z.ZodMiniString<string>;
        }, z.core.$strip>;
    }
    /** Schemas for the uploadVerifiedTokenLogo operation. */
    namespace uploadVerifiedTokenLogo {
        /** Query parameters for a logo upload. */
        const Query: 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>>;
        }, z.core.$strict>;
        /** Response after a successful logo upload. */
        const Response: z.ZodMiniObject<{
            key: z.ZodMiniString<string>;
            path: z.ZodMiniString<string>;
        }, z.core.$strip>;
    }
    /** Schemas for the getVerifiedTokenLogo operation. */
    namespace getVerifiedTokenLogo {
        /** Query parameters for a logo read. */
        const Query: 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>>;
        }, z.core.$strict>;
    }
    /**
     * A verification request with reviewer context: the management wire shape
     * plus the requesting org's name and the reviewing admin's email.
     */
    const Request: z.ZodMiniObject<{
        address: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
        currency: z.ZodMiniString<string>;
        decimals: z.ZodMiniNumber<number>;
        logoUri: z.ZodMiniOptional<z.ZodMiniURL>;
        name: z.ZodMiniString<string>;
        symbol: z.ZodMiniString<string>;
        chainId: z.ZodMiniNumber<number>;
        createdAt: z.ZodMiniISODateTime;
        id: z.ZodMiniString<string>;
        logo: z.ZodMiniOptional<z.ZodMiniString<string>>;
        note: z.ZodMiniNullable<z.ZodMiniString<string>>;
        orgId: z.ZodMiniString<string>;
        requestedBy: z.ZodMiniString<string>;
        reviewNote: z.ZodMiniNullable<z.ZodMiniString<string>>;
        reviewedAt: z.ZodMiniNullable<z.ZodMiniISODateTime>;
        status: z.ZodMiniEnum<{
            approved: "approved";
            denied: "denied";
            pending: "pending";
        }>;
        updatedAt: z.ZodMiniISODateTime;
        orgName: z.ZodMiniNullable<z.ZodMiniString<string>>;
        reviewedBy: z.ZodMiniNullable<z.ZodMiniString<string>>;
    }, z.core.$strip>;
    /** Path parameters addressing one verification request. */
    const RequestParams: z.ZodMiniObject<{
        requestId: z.ZodMiniString<string>;
    }, z.core.$strip>;
    /** Schemas for the listVerifiedTokenRequests operation. */
    namespace listVerifiedTokenRequests {
        /** Query parameters for the request queue. */
        const Query: z.ZodMiniObject<{
            status: z.ZodMiniDefault<z.ZodMiniEnum<{
                approved: "approved";
                denied: "denied";
                pending: "pending";
            }>>;
        }, z.core.$strict>;
        /** Response: requests in the selected status, oldest first. */
        const Response: z.ZodMiniObject<{
            data: z.ZodMiniArray<z.ZodMiniObject<{
                address: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
                currency: z.ZodMiniString<string>;
                decimals: z.ZodMiniNumber<number>;
                logoUri: z.ZodMiniOptional<z.ZodMiniURL>;
                name: z.ZodMiniString<string>;
                symbol: z.ZodMiniString<string>;
                chainId: z.ZodMiniNumber<number>;
                createdAt: z.ZodMiniISODateTime;
                id: z.ZodMiniString<string>;
                logo: z.ZodMiniOptional<z.ZodMiniString<string>>;
                note: z.ZodMiniNullable<z.ZodMiniString<string>>;
                orgId: z.ZodMiniString<string>;
                requestedBy: z.ZodMiniString<string>;
                reviewNote: z.ZodMiniNullable<z.ZodMiniString<string>>;
                reviewedAt: z.ZodMiniNullable<z.ZodMiniISODateTime>;
                status: z.ZodMiniEnum<{
                    approved: "approved";
                    denied: "denied";
                    pending: "pending";
                }>;
                updatedAt: z.ZodMiniISODateTime;
                orgName: z.ZodMiniNullable<z.ZodMiniString<string>>;
                reviewedBy: z.ZodMiniNullable<z.ZodMiniString<string>>;
            }, z.core.$strip>>;
        }, z.core.$strip>;
    }
    /** Schemas for the denyVerifiedTokenRequest operation. */
    namespace denyVerifiedTokenRequest {
        /** Request body for a denial. */
        const Body: z.ZodMiniObject<{
            reviewNote: z.ZodMiniOptional<z.ZodMiniString<string>>;
        }, z.core.$strip>;
    }
    /** Response shared by the approve and deny operations. */
    namespace reviewVerifiedTokenRequest {
        /** The reviewed request. */
        const Response: z.ZodMiniObject<{
            data: z.ZodMiniObject<{
                address: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
                currency: z.ZodMiniString<string>;
                decimals: z.ZodMiniNumber<number>;
                logoUri: z.ZodMiniOptional<z.ZodMiniURL>;
                name: z.ZodMiniString<string>;
                symbol: z.ZodMiniString<string>;
                chainId: z.ZodMiniNumber<number>;
                createdAt: z.ZodMiniISODateTime;
                id: z.ZodMiniString<string>;
                logo: z.ZodMiniOptional<z.ZodMiniString<string>>;
                note: z.ZodMiniNullable<z.ZodMiniString<string>>;
                orgId: z.ZodMiniString<string>;
                requestedBy: z.ZodMiniString<string>;
                reviewNote: z.ZodMiniNullable<z.ZodMiniString<string>>;
                reviewedAt: z.ZodMiniNullable<z.ZodMiniISODateTime>;
                status: z.ZodMiniEnum<{
                    approved: "approved";
                    denied: "denied";
                    pending: "pending";
                }>;
                updatedAt: z.ZodMiniISODateTime;
                orgName: z.ZodMiniNullable<z.ZodMiniString<string>>;
                reviewedBy: z.ZodMiniNullable<z.ZodMiniString<string>>;
            }, z.core.$strip>;
        }, z.core.$strip>;
    }
    /** Schemas for the replaceVerifiedTokens operation. */
    namespace replaceVerifiedTokens {
        /** Query parameters for a bulk replace. */
        const Query: 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>>;
        }, z.core.$strict>;
        /** Request body for replacing a chain's entire verified list. */
        const Body: z.ZodMiniObject<{
            tokens: z.ZodMiniArray<z.ZodMiniObject<{
                address: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
                currency: z.ZodMiniString<string>;
                decimals: z.ZodMiniNumber<number>;
                logoUri: z.ZodMiniOptional<z.ZodMiniURL>;
                name: z.ZodMiniString<string>;
                symbol: z.ZodMiniString<string>;
            }, z.core.$strip>>;
        }, z.core.$strip>;
        /** Response after a successful bulk replace. */
        const Response: z.ZodMiniObject<{
            data: z.ZodMiniArray<z.ZodMiniObject<{
                address: z.ZodMiniPipe<z.ZodMiniTemplateLiteral<`0x${string}`>, z.ZodMiniTransform<`0x${string}`, `0x${string}`>>;
                currency: z.ZodMiniString<string>;
                decimals: z.ZodMiniNumber<number>;
                logoUri: z.ZodMiniOptional<z.ZodMiniURL>;
                name: z.ZodMiniString<string>;
                symbol: z.ZodMiniString<string>;
                id: z.ZodMiniString<string>;
            }, z.core.$strip>>;
            version: z.ZodMiniString<string>;
        }, z.core.$strip>;
    }
}
/**
 * Management routes for the curated verified-token list, backed by the app
 * database (snapshot rows). Mutations accept an optional `If-Match`
 * precondition (`412` on mismatch).
 *
 * - `POST /` creates a token (`409` on a duplicate address or symbol).
 * - `PUT /` replaces a chain's entire list (seed/rollback).
 * - `PATCH /:address` partially updates a token (`404` if absent).
 * - `DELETE /:address` removes a token (`404` if absent).
 * - `PUT /:address/logo` uploads a curated logo SVG (gated on `assets`).
 * - `GET /requests` lists organization verification requests.
 * - `POST /requests/:requestId/approve|deny` reviews a request.
 */
export declare function verifiedTokens(): import("hono/hono-base").HonoBase<App.Environment, {
    "/": {
        $get: {
            output: {
                data: {
                    address: `0x${string}`;
                    currency: string;
                    decimals: number;
                    logoUri?: string | undefined;
                    name: string;
                    symbol: string;
                    id: string;
                }[];
                version: string | null;
            };
            outputFormat: "json";
            status: import("hono/utils/http-status").ContentfulStatusCode;
            input: {
                query: {
                    chainId: string | string[];
                };
            };
        };
    };
} & {
    "/": {
        $post: {
            output: {
                error: {
                    code: string;
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 400 | 413 | 415;
            input: {
                json: {
                    address: `0x${string}`;
                    currency: string;
                    decimals: number;
                    logoUri?: string | undefined;
                    name: string;
                    symbol: string;
                    chainId: unknown;
                    logo?: string | undefined;
                };
            };
        } | {
            output: {
                error: {
                    code: "upstream_error";
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 502;
            input: {
                json: {
                    address: `0x${string}`;
                    currency: string;
                    decimals: number;
                    logoUri?: string | undefined;
                    name: string;
                    symbol: string;
                    chainId: unknown;
                    logo?: string | undefined;
                };
            };
        } | {
            output: {
                error: {
                    code: "verified_token_not_found";
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 404;
            input: {
                json: {
                    address: `0x${string}`;
                    currency: string;
                    decimals: number;
                    logoUri?: string | undefined;
                    name: string;
                    symbol: string;
                    chainId: unknown;
                    logo?: string | undefined;
                };
            };
        } | {
            output: {
                error: {
                    code: "assets_not_enabled";
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 404;
            input: {
                json: {
                    address: `0x${string}`;
                    currency: string;
                    decimals: number;
                    logoUri?: string | undefined;
                    name: string;
                    symbol: string;
                    chainId: unknown;
                    logo?: string | undefined;
                };
            };
        } | {
            output: {
                data: {
                    address: `0x${string}`;
                    currency: string;
                    decimals: number;
                    logoUri?: string | undefined;
                    name: string;
                    symbol: string;
                    id: string;
                };
                version: string;
            };
            outputFormat: "json";
            status: import("hono/utils/http-status").ContentfulStatusCode;
            input: {
                json: {
                    address: `0x${string}`;
                    currency: string;
                    decimals: number;
                    logoUri?: string | undefined;
                    name: string;
                    symbol: string;
                    chainId: unknown;
                    logo?: string | undefined;
                };
            };
        } | {
            output: {
                error: {
                    code: "duplicate_address";
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 409;
            input: {
                json: {
                    address: `0x${string}`;
                    currency: string;
                    decimals: number;
                    logoUri?: string | undefined;
                    name: string;
                    symbol: string;
                    chainId: unknown;
                    logo?: string | undefined;
                };
            };
        } | {
            output: {
                error: {
                    code: "duplicate_symbol";
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 409;
            input: {
                json: {
                    address: `0x${string}`;
                    currency: string;
                    decimals: number;
                    logoUri?: string | undefined;
                    name: string;
                    symbol: string;
                    chainId: unknown;
                    logo?: string | undefined;
                };
            };
        } | {
            output: {
                error: {
                    code: "version_mismatch";
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 412;
            input: {
                json: {
                    address: `0x${string}`;
                    currency: string;
                    decimals: number;
                    logoUri?: string | undefined;
                    name: string;
                    symbol: string;
                    chainId: unknown;
                    logo?: string | undefined;
                };
            };
        };
    };
} & {
    "/": {
        $put: {
            output: {
                error: {
                    code: string;
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 400 | 413 | 415;
            input: {
                query: {
                    chainId: string | string[];
                };
            } & {
                json: {
                    tokens: {
                        address: `0x${string}`;
                        currency: string;
                        decimals: number;
                        logoUri?: string | undefined;
                        name: string;
                        symbol: string;
                    }[];
                };
            };
        } | {
            output: {
                error: {
                    code: "upstream_error";
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 502;
            input: {
                query: {
                    chainId: string | string[];
                };
            } & {
                json: {
                    tokens: {
                        address: `0x${string}`;
                        currency: string;
                        decimals: number;
                        logoUri?: string | undefined;
                        name: string;
                        symbol: string;
                    }[];
                };
            };
        } | {
            output: {
                error: {
                    code: "verified_token_not_found";
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 404;
            input: {
                query: {
                    chainId: string | string[];
                };
            } & {
                json: {
                    tokens: {
                        address: `0x${string}`;
                        currency: string;
                        decimals: number;
                        logoUri?: string | undefined;
                        name: string;
                        symbol: string;
                    }[];
                };
            };
        } | {
            output: {
                error: {
                    code: "duplicate_address";
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 409;
            input: {
                query: {
                    chainId: string | string[];
                };
            } & {
                json: {
                    tokens: {
                        address: `0x${string}`;
                        currency: string;
                        decimals: number;
                        logoUri?: string | undefined;
                        name: string;
                        symbol: string;
                    }[];
                };
            };
        } | {
            output: {
                error: {
                    code: "duplicate_symbol";
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 409;
            input: {
                query: {
                    chainId: string | string[];
                };
            } & {
                json: {
                    tokens: {
                        address: `0x${string}`;
                        currency: string;
                        decimals: number;
                        logoUri?: string | undefined;
                        name: string;
                        symbol: string;
                    }[];
                };
            };
        } | {
            output: {
                error: {
                    code: "version_mismatch";
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 412;
            input: {
                query: {
                    chainId: string | string[];
                };
            } & {
                json: {
                    tokens: {
                        address: `0x${string}`;
                        currency: string;
                        decimals: number;
                        logoUri?: string | undefined;
                        name: string;
                        symbol: string;
                    }[];
                };
            };
        } | {
            output: {
                data: {
                    address: `0x${string}`;
                    currency: string;
                    decimals: number;
                    logoUri?: string | undefined;
                    name: string;
                    symbol: string;
                    id: string;
                }[];
                version: string;
            };
            outputFormat: "json";
            status: import("hono/utils/http-status").ContentfulStatusCode;
            input: {
                query: {
                    chainId: string | string[];
                };
            } & {
                json: {
                    tokens: {
                        address: `0x${string}`;
                        currency: string;
                        decimals: number;
                        logoUri?: string | undefined;
                        name: string;
                        symbol: string;
                    }[];
                };
            };
        };
    };
} & {
    "/:address": {
        $patch: {
            output: {
                error: {
                    code: string;
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 400 | 413 | 415;
            input: {
                param: {
                    address: `0x${string}`;
                };
            } & {
                query: {
                    chainId: string | string[];
                };
            } & {
                json: {
                    currency?: string | undefined;
                    decimals?: number | undefined;
                    logoUri?: string | undefined;
                    name?: string | undefined;
                    symbol?: 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[];
                };
            } & {
                json: {
                    currency?: string | undefined;
                    decimals?: number | undefined;
                    logoUri?: string | undefined;
                    name?: string | undefined;
                    symbol?: string | undefined;
                };
            };
        } | {
            output: {
                error: {
                    code: "verified_token_not_found";
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 404;
            input: {
                param: {
                    address: `0x${string}`;
                };
            } & {
                query: {
                    chainId: string | string[];
                };
            } & {
                json: {
                    currency?: string | undefined;
                    decimals?: number | undefined;
                    logoUri?: string | undefined;
                    name?: string | undefined;
                    symbol?: string | undefined;
                };
            };
        } | {
            output: {
                data: {
                    address: `0x${string}`;
                    currency: string;
                    decimals: number;
                    logoUri?: string | undefined;
                    name: string;
                    symbol: string;
                    id: string;
                };
                version: string;
            };
            outputFormat: "json";
            status: import("hono/utils/http-status").ContentfulStatusCode;
            input: {
                param: {
                    address: `0x${string}`;
                };
            } & {
                query: {
                    chainId: string | string[];
                };
            } & {
                json: {
                    currency?: string | undefined;
                    decimals?: number | undefined;
                    logoUri?: string | undefined;
                    name?: string | undefined;
                    symbol?: string | undefined;
                };
            };
        } | {
            output: {
                error: {
                    code: "duplicate_address";
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 409;
            input: {
                param: {
                    address: `0x${string}`;
                };
            } & {
                query: {
                    chainId: string | string[];
                };
            } & {
                json: {
                    currency?: string | undefined;
                    decimals?: number | undefined;
                    logoUri?: string | undefined;
                    name?: string | undefined;
                    symbol?: string | undefined;
                };
            };
        } | {
            output: {
                error: {
                    code: "duplicate_symbol";
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 409;
            input: {
                param: {
                    address: `0x${string}`;
                };
            } & {
                query: {
                    chainId: string | string[];
                };
            } & {
                json: {
                    currency?: string | undefined;
                    decimals?: number | undefined;
                    logoUri?: string | undefined;
                    name?: string | undefined;
                    symbol?: string | undefined;
                };
            };
        } | {
            output: {
                error: {
                    code: "version_mismatch";
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 412;
            input: {
                param: {
                    address: `0x${string}`;
                };
            } & {
                query: {
                    chainId: string | string[];
                };
            } & {
                json: {
                    currency?: string | undefined;
                    decimals?: number | undefined;
                    logoUri?: string | undefined;
                    name?: string | undefined;
                    symbol?: string | undefined;
                };
            };
        };
    };
} & {
    "/:address": {
        $delete: {
            output: {
                error: {
                    code: string;
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 400 | 413 | 415;
            input: {
                param: {
                    address: `0x${string}`;
                };
            } & {
                query: {
                    chainId: string | string[];
                };
            };
        } | {
            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[];
                };
            };
        } | {
            output: {
                error: {
                    code: "verified_token_not_found";
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 404;
            input: {
                param: {
                    address: `0x${string}`;
                };
            } & {
                query: {
                    chainId: string | string[];
                };
            };
        } | {
            output: {
                error: {
                    code: "duplicate_address";
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 409;
            input: {
                param: {
                    address: `0x${string}`;
                };
            } & {
                query: {
                    chainId: string | string[];
                };
            };
        } | {
            output: {
                error: {
                    code: "duplicate_symbol";
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 409;
            input: {
                param: {
                    address: `0x${string}`;
                };
            } & {
                query: {
                    chainId: string | string[];
                };
            };
        } | {
            output: {
                error: {
                    code: "version_mismatch";
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 412;
            input: {
                param: {
                    address: `0x${string}`;
                };
            } & {
                query: {
                    chainId: string | string[];
                };
            };
        } | {
            output: {
                version: string;
            };
            outputFormat: "json";
            status: import("hono/utils/http-status").ContentfulStatusCode;
            input: {
                param: {
                    address: `0x${string}`;
                };
            } & {
                query: {
                    chainId: string | string[];
                };
            };
        };
    };
} & {
    "/:address/logo": {
        $get: {
            output: ArrayBuffer;
            outputFormat: "body";
            status: import("hono/utils/http-status").ContentfulStatusCode;
            input: {
                param: {
                    address: `0x${string}`;
                };
            } & {
                query: {
                    chainId: string | string[];
                };
            };
        } | {
            output: {
                error: {
                    code: "logo_not_found";
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 404;
            input: {
                param: {
                    address: `0x${string}`;
                };
            } & {
                query: {
                    chainId: string | string[];
                };
            };
        };
    };
} & {
    "/:address/logo": {
        $put: {
            output: {
                error: {
                    code: "body_invalid";
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 400;
            input: {
                param: {
                    address: `0x${string}`;
                };
            } & {
                query: {
                    chainId: string | string[];
                };
            };
        } | {
            output: {
                error: {
                    code: "assets_not_enabled";
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 404;
            input: {
                param: {
                    address: `0x${string}`;
                };
            } & {
                query: {
                    chainId: string | string[];
                };
            };
        } | {
            output: {
                error: {
                    code: "unsupported_media_type";
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 415;
            input: {
                param: {
                    address: `0x${string}`;
                };
            } & {
                query: {
                    chainId: string | string[];
                };
            };
        } | {
            output: {
                error: {
                    code: "payload_too_large";
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 413;
            input: {
                param: {
                    address: `0x${string}`;
                };
            } & {
                query: {
                    chainId: string | string[];
                };
            };
        } | {
            output: {
                key: string;
                path: string;
            };
            outputFormat: "json";
            status: import("hono/utils/http-status").ContentfulStatusCode;
            input: {
                param: {
                    address: `0x${string}`;
                };
            } & {
                query: {
                    chainId: string | string[];
                };
            };
        };
    };
} & {
    "/requests": {
        $get: {
            output: {
                data: {
                    address: `0x${string}`;
                    currency: string;
                    decimals: number;
                    logoUri?: string | undefined;
                    name: string;
                    symbol: string;
                    chainId: number;
                    createdAt: string;
                    id: string;
                    logo?: string | undefined;
                    note: string | null;
                    orgId: string;
                    requestedBy: string;
                    reviewNote: string | null;
                    reviewedAt: string | null;
                    status: "approved" | "denied" | "pending";
                    updatedAt: string;
                    orgName: string | null;
                    reviewedBy: string | null;
                }[];
            };
            outputFormat: "json";
            status: import("hono/utils/http-status").ContentfulStatusCode;
            input: {
                query?: {
                    status?: string | string[];
                } | undefined;
            };
        };
    };
} & {
    "/requests/:requestId/approve": {
        $post: {
            output: {
                error: {
                    code: string;
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 400 | 413 | 415;
            input: {
                param: {
                    requestId: string;
                };
            };
        } | {
            output: {
                error: {
                    code: "upstream_error";
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 502;
            input: {
                param: {
                    requestId: string;
                };
            };
        } | {
            output: {
                error: {
                    code: "verified_token_not_found";
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 404;
            input: {
                param: {
                    requestId: string;
                };
            };
        } | {
            output: {
                error: {
                    code: "request_not_pending";
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 409;
            input: {
                param: {
                    requestId: string;
                };
            };
        } | {
            output: {
                error: {
                    code: "verified_token_request_not_found";
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 404;
            input: {
                param: {
                    requestId: string;
                };
            };
        } | {
            output: {
                error: {
                    code: "assets_not_enabled";
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 404;
            input: {
                param: {
                    requestId: string;
                };
            };
        } | {
            output: {
                error: {
                    code: "duplicate_address";
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 409;
            input: {
                param: {
                    requestId: string;
                };
            };
        } | {
            output: {
                error: {
                    code: "duplicate_symbol";
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 409;
            input: {
                param: {
                    requestId: string;
                };
            };
        } | {
            output: {
                error: {
                    code: "version_mismatch";
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 412;
            input: {
                param: {
                    requestId: string;
                };
            };
        } | {
            output: {
                data: {
                    address: `0x${string}`;
                    currency: string;
                    decimals: number;
                    logoUri?: string | undefined;
                    name: string;
                    symbol: string;
                    chainId: number;
                    createdAt: string;
                    id: string;
                    logo?: string | undefined;
                    note: string | null;
                    orgId: string;
                    requestedBy: string;
                    reviewNote: string | null;
                    reviewedAt: string | null;
                    status: "approved" | "denied" | "pending";
                    updatedAt: string;
                    orgName: string | null;
                    reviewedBy: string | null;
                };
            };
            outputFormat: "json";
            status: import("hono/utils/http-status").ContentfulStatusCode;
            input: {
                param: {
                    requestId: string;
                };
            };
        };
    };
} & {
    "/requests/:requestId/deny": {
        $post: {
            output: {
                error: {
                    code: string;
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 400 | 413 | 415;
            input: {
                param: {
                    requestId: string;
                };
            } & {
                json: {
                    reviewNote?: string | undefined;
                };
            };
        } | {
            output: {
                error: {
                    code: "upstream_error";
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 502;
            input: {
                param: {
                    requestId: string;
                };
            } & {
                json: {
                    reviewNote?: string | undefined;
                };
            };
        } | {
            output: {
                error: {
                    code: "verified_token_not_found";
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 404;
            input: {
                param: {
                    requestId: string;
                };
            } & {
                json: {
                    reviewNote?: string | undefined;
                };
            };
        } | {
            output: {
                error: {
                    code: "request_not_pending";
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 409;
            input: {
                param: {
                    requestId: string;
                };
            } & {
                json: {
                    reviewNote?: string | undefined;
                };
            };
        } | {
            output: {
                error: {
                    code: "verified_token_request_not_found";
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 404;
            input: {
                param: {
                    requestId: string;
                };
            } & {
                json: {
                    reviewNote?: string | undefined;
                };
            };
        } | {
            output: {
                error: {
                    code: "duplicate_address";
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 409;
            input: {
                param: {
                    requestId: string;
                };
            } & {
                json: {
                    reviewNote?: string | undefined;
                };
            };
        } | {
            output: {
                error: {
                    code: "duplicate_symbol";
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 409;
            input: {
                param: {
                    requestId: string;
                };
            } & {
                json: {
                    reviewNote?: string | undefined;
                };
            };
        } | {
            output: {
                error: {
                    code: "version_mismatch";
                    details?: readonly Response.error.Detail[] | undefined;
                    message: string;
                };
                requestId: string;
            };
            outputFormat: "json";
            status: 412;
            input: {
                param: {
                    requestId: string;
                };
            } & {
                json: {
                    reviewNote?: string | undefined;
                };
            };
        } | {
            output: {
                data: {
                    address: `0x${string}`;
                    currency: string;
                    decimals: number;
                    logoUri?: string | undefined;
                    name: string;
                    symbol: string;
                    chainId: number;
                    createdAt: string;
                    id: string;
                    logo?: string | undefined;
                    note: string | null;
                    orgId: string;
                    requestedBy: string;
                    reviewNote: string | null;
                    reviewedAt: string | null;
                    status: "approved" | "denied" | "pending";
                    updatedAt: string;
                    orgName: string | null;
                    reviewedBy: string | null;
                };
            };
            outputFormat: "json";
            status: import("hono/utils/http-status").ContentfulStatusCode;
            input: {
                param: {
                    requestId: string;
                };
            } & {
                json: {
                    reviewNote?: string | undefined;
                };
            };
        };
    };
}, "/", "/requests/:requestId/deny">;
//# sourceMappingURL=verified-tokens.d.ts.map