import type { ActorMethodReturnType, BaseActor, FunctionName } from "@ic-reactor/core";
import { CandidDisplayReactor } from "./display-reactor.js";
import type { CandidDisplayReactorParameters, DynamicMethodOptions } from "./types.js";
import { ArgumentsMeta, ArgumentsServiceMeta } from "./visitor/arguments/index.js";
import { MethodMeta, MethodResult, ServiceMeta } from "./visitor/returns/index.js";
/**
 * MetadataDisplayReactor combines visitor-based metadata generation
 * for both input forms and result display.
 *
 * ## Architecture
 *
 * It extends the base Reactor and adds metadata generation capabilities.
 * Unlike DisplayReactor, it does not use a separate codec for transformation.
 * Instead, it uses the metadata visitor to resolve raw values into display-ready structures.
 *
 * ## Usage
 *
 * ```typescript
 * const reactor = new MetadataDisplayReactor({
 *   canisterId: "ryjl3-tyaaa-aaaaa-aaaba-cai",
 *   clientManager,
 *   name: "ICPLedger",
 * })
 *
 * await reactor.initialize()
 *
 * // Get form metadata
 * const argMeta = reactor.getInputMeta("icrc1_transfer")
 * console.log(argMeta.args)     // Field descriptors
 * console.log(argMeta.defaults) // Default values
 *
 * // Get result metadata
 * const resultMeta = reactor.getOutputMeta("icrc1_transfer")
 *
 * // Call with display types
 * const result = await reactor.callMethod({
 *   functionName: "icrc1_transfer",
 *   args: [{ to: { owner: "aaaaa-aa" }, amount: "1000000" }]
 * })
 * ```
 */
declare module "@ic-reactor/core" {
    interface TransformArgsRegistry<T> {
        metadataDisplay: TransformArgsRegistry<T>["display"];
    }
    interface TransformReturnRegistry<T, A = BaseActor> {
        metadataDisplay: MethodResult<A>;
    }
}
export declare class MetadataDisplayReactor<A = BaseActor> extends CandidDisplayReactor<A, "metadataDisplay"> {
    readonly transform: "metadataDisplay";
    private argumentMeta;
    private resultMeta;
    private static argVisitor;
    private static resultVisitor;
    constructor(config: CandidDisplayReactorParameters<A>);
    /**
     * Initializes the reactor by parsing Candid and generating all metadata.
     */
    initialize(): Promise<void>;
    /**
     * Generate all metadata from the service interface using visitors.
     */
    private generateMetadata;
    /**
     * Get input field metadata for a method.
     * Use this to generate input forms.
     *
     * @param methodName The method name to get metadata for
     * @returns ArgumentsMeta containing args, defaults, and validation schema
     */
    getInputMeta<M extends FunctionName<A>>(methodName: M): ArgumentsMeta<A, M> | undefined;
    /**
     * Get output field metadata for a method.
     * Use this to render results.
     *
     * @param methodName The method name to get metadata for
     * @returns MethodMeta containing return schema and resolve function
     */
    getOutputMeta<M extends FunctionName<A>>(methodName: M): MethodMeta<A, M> | undefined;
    /**
     * Get all input metadata for all methods.
     */
    getAllInputMeta(): ArgumentsServiceMeta<A> | null;
    /**
     * Get all output metadata for all methods.
     */
    getAllOutputMeta(): ServiceMeta<A> | null;
    /**
     * Register a dynamic method by its Candid signature.
     * After registration, all DisplayReactor methods work with display type transformations.
     */
    registerMethod(options: DynamicMethodOptions): Promise<void>;
    protected transformResult<M extends FunctionName<A>>(methodName: M, result: ActorMethodReturnType<A[M]>): MethodResult<A>;
    /**
     * Perform a dynamic call and return result with metadata.
     *
     * @param options Method registration and call options
     * @returns Object containing the result and metadata
     */
    callDynamicWithMeta<T = unknown>(options: DynamicMethodOptions & {
        args?: unknown[];
    }): Promise<{
        result: T;
        meta: MethodMeta<A>;
    }>;
}
//# sourceMappingURL=metadata-display-reactor.d.ts.map