import type { BaseActor, TransformArgsRegistry, TransformKey } from "@ic-reactor/core";
import type { CandidReactorParameters, DynamicMethodOptions } from "./types.js";
import { Reactor } from "@ic-reactor/core";
import { CandidAdapter } from "./adapter.js";
export declare class CandidReactor<A = BaseActor, T extends TransformKey = "candid"> extends Reactor<A, T> {
    transform: keyof TransformArgsRegistry<unknown>;
    adapter: CandidAdapter;
    private candidSource?;
    constructor(config: CandidReactorParameters);
    /**
     * Initializes the reactor by parsing the provided Candid string or fetching it from the network.
     * This updates the internal service definition with the actual canister interface.
     *
     * After initialization, all standard Reactor methods (callMethod, fetchQuery, etc.) work.
     */
    initialize(): Promise<void>;
    /**
     * Register a dynamic method by its Candid signature.
     * After registration, all standard Reactor methods work with this method name.
     *
     * @example
     * ```typescript
     * // Register a method
     * await reactor.registerMethod({
     *   functionName: "icrc1_balance_of",
     *   candid: "(record { owner : principal }) -> (nat) query"
     * })
     *
     * // Now use standard Reactor methods!
     * const balance = await reactor.callMethod({
     *   functionName: "icrc1_balance_of",
     *   args: [{ owner }]
     * })
     *
     * // Or with caching
     * const cachedBalance = await reactor.fetchQuery({
     *   functionName: "icrc1_balance_of",
     *   args: [{ owner }]
     * })
     * ```
     */
    registerMethod(options: DynamicMethodOptions): Promise<void>;
    /**
     * Register multiple methods at once.
     */
    registerMethods(methods: DynamicMethodOptions[]): Promise<void>;
    /**
     * Check if a method is registered (either from initialize or registerMethod).
     */
    hasMethod(functionName: string): boolean;
    /**
     * Get all registered method names.
     */
    getMethodNames(): string[];
    /**
     * Perform a dynamic update call in one step.
     * Registers the method if not already registered, then calls it.
     *
     * @example
     * ```typescript
     * const result = await reactor.callDynamic({
     *   functionName: "transfer",
     *   candid: "(record { to : principal; amount : nat }) -> (variant { Ok : nat; Err : text })",
     *   args: [{ to: Principal.fromText("..."), amount: 100n }]
     * })
     * ```
     */
    callDynamic<T = unknown>(options: DynamicMethodOptions & {
        args?: unknown[];
    }): Promise<T>;
    /**
     * Perform a dynamic query call in one step.
     * Registers the method if not already registered, then calls it.
     *
     * @example
     * ```typescript
     * const balance = await reactor.queryDynamic({
     *   functionName: "icrc1_balance_of",
     *   candid: "(record { owner : principal }) -> (nat) query",
     *   args: [{ owner: Principal.fromText("...") }]
     * })
     * ```
     */
    queryDynamic<T = unknown>(options: DynamicMethodOptions & {
        args?: unknown[];
    }): Promise<T>;
    /**
     * Fetch with dynamic Candid and TanStack Query caching.
     * Registers the method if not already registered, then fetches with caching.
     *
     * @example
     * ```typescript
     * const balance = await reactor.fetchQueryDynamic({
     *   functionName: "icrc1_balance_of",
     *   candid: "(record { owner : principal }) -> (nat) query",
     *   args: [{ owner }]
     * })
     * ```
     */
    fetchQueryDynamic<T = unknown>(options: DynamicMethodOptions & {
        args?: unknown[];
    }): Promise<T>;
}
//# sourceMappingURL=reactor.d.ts.map