/** Prepared arguments holding a value `encodeActionArguments` cannot encode exactly. */
export declare class UnsupportedActionArgumentError extends Error {
    /** Where the value sits, as `key.nested[0]`; empty for the arguments themselves. */
    readonly path: string;
    /** What the value is: `Map`, `function`, `accessor`, `circular reference`, and so on. */
    readonly kind: string;
    constructor(path: string, kind: string);
}
/** Prepared arguments as a call runs them, and the hash of their exact encoding. */
export interface ActionArgumentsSnapshot {
    /**
     * A deep, frozen, plain-data copy, read once from the prepared value. Hand
     * each consumer `copyActionArguments(value)`, never this: freezing does not
     * stop `setTime` on a Date, so a consumer holding it could change what the
     * next one reads.
     */
    readonly value: unknown;
    /** SHA-256 hex of `encodeActionArguments(value)`. */
    readonly hash: string;
}
/**
 * Copies prepared arguments into the one value a call's gates, identities and
 * handler all copy from, and hashes it in the same pass. Each property is read
 * once from its descriptor, so an accessor, which could answer differently on
 * the next read, is refused rather than sampled. Throws as
 * `encodeActionArguments` does.
 */
export declare function snapshotActionArguments(value: unknown): ActionArgumentsSnapshot;
/**
 * The exact encoding of prepared arguments. Approval grants, replays,
 * recoveries and read reuse bind it, so arguments that would run differently
 * never share one: every value is tagged with its type, plain object keys are
 * sorted, an `undefined` property differs from a missing one, and a Date
 * encodes as its ISO time. Any other value (a Map, a class instance, a
 * function, an accessor, an invalid Date, a cycle) throws
 * `UnsupportedActionArgumentError` rather than encoding approximately.
 */
export declare function encodeActionArguments(value: unknown): string;
/** SHA-256 hex of `encodeActionArguments`; throws as it does. */
export declare function actionArgumentsHash(value: unknown): string;
/** A mutable deep copy of a snapshot, for one consumer that may change it. */
export declare function copyActionArguments(snapshot: unknown): unknown;