import { Address, Builder, Cell, Message, OutAction, ShardAccount, Slice, Transaction, TupleItem, TupleReader } from '@ton/core';
import { Blockchain } from './Blockchain';
import { ExtraCurrency } from '../utils/ec';
import { EmulationResult, RunCommonArgs, TickOrTock } from '../executor/Executor';
export declare function createShardAccount(args: {
    address?: Address;
    code: Cell;
    data: Cell;
    balance: bigint;
    workchain?: number;
}): ShardAccount;
export declare function createEmptyShardAccount(address: Address): ShardAccount;
type ExtendedActionType = OutAction['type'] | 'unknown';
export type OutActionMalformed = {
    type: 'malformed';
    subtype: ExtendedActionType;
    data: Cell;
};
export type OutActionExtended = OutAction | OutActionMalformed;
export declare function storeOutListExt(actions: OutActionExtended[]): (builder: Builder) => void;
export declare function loadOutListExt(data: Slice): OutActionExtended[];
export type Verbosity = 'none' | 'vm_logs' | 'vm_logs_location' | 'vm_logs_gas' | 'vm_logs_full' | 'vm_logs_verbose';
export type LogsVerbosity = {
    print: boolean;
    blockchainLogs: boolean;
    vmLogs: Verbosity;
    debugLogs: boolean;
};
export type SmartContractTransaction = Transaction & {
    blockchainLogs: string;
    vmLogs: string;
    debugLogs: string;
    callStack?: string;
    oldStorage?: Cell;
    newStorage?: Cell;
    outActions?: OutActionExtended[];
};
export type MessageParams = Partial<{
    now: number;
    randomSeed: Buffer;
    ignoreChksig: boolean;
}>;
export type GetMethodParams = Partial<{
    now: number;
    randomSeed: Buffer;
    gasLimit: bigint;
}>;
export type GetMethodResult = {
    stack: TupleItem[];
    stackReader: TupleReader;
    exitCode: number;
    gasUsed: bigint;
    blockchainLogs: string;
    vmLogs: string;
    debugLogs: string;
};
export declare class GetMethodError extends Error {
    exitCode: number;
    gasUsed: bigint;
    blockchainLogs: string;
    vmLogs: string;
    debugLogs: string;
    constructor(exitCode: number, gasUsed: bigint, blockchainLogs: string, vmLogs: string, debugLogs: string);
}
export declare class TimeError extends Error {
    address: Address;
    previousTxTime: number;
    currentTime: number;
    constructor(address: Address, previousTxTime: number, currentTime: number);
}
export declare class EmulationError extends Error {
    error: string;
    vmLogs?: string | undefined;
    exitCode?: number | undefined;
    blockchainLogs?: string | undefined;
    debugLogs?: string | undefined;
    constructor(error: string, vmLogs?: string | undefined, exitCode?: number | undefined, blockchainLogs?: string | undefined, debugLogs?: string | undefined);
}
export type SmartContractSnapshot = {
    address: Address;
    account: ShardAccount;
    lastTxTime: number;
    verbosity?: Partial<LogsVerbosity>;
};
export declare class SmartContract {
    readonly address: Address;
    readonly blockchain: Blockchain;
    private _account;
    private parsedAccount?;
    private lastTxTime;
    private _verbosity?;
    private _debug?;
    constructor(shardAccount: ShardAccount, blockchain: Blockchain);
    snapshot(): SmartContractSnapshot;
    loadFrom(snapshot: SmartContractSnapshot): void;
    get ec(): ExtraCurrency;
    set ec(nv: ExtraCurrency);
    get balance(): bigint;
    set balance(v: bigint);
    get lastTransactionHash(): bigint;
    get lastTransactionLt(): bigint;
    get accountState(): import("@ton/core").AccountState | undefined;
    get account(): ShardAccount;
    set account(account: ShardAccount);
    static create(blockchain: Blockchain, args: {
        address: Address;
        code: Cell;
        data: Cell;
        balance: bigint;
    }): SmartContract;
    static empty(blockchain: Blockchain, address: Address): SmartContract;
    protected createCommonArgs(params?: MessageParams): RunCommonArgs;
    receiveMessage(message: Message, params?: MessageParams, callStack?: string): Promise<SmartContractTransaction>;
    runTickTock(which: TickOrTock, params?: MessageParams): Promise<SmartContractTransaction>;
    protected runCommon(run: () => Promise<EmulationResult>, callStack?: string): Promise<SmartContractTransaction>;
    get(method: string | number, stack?: TupleItem[], params?: GetMethodParams): Promise<GetMethodResult>;
    get verbosity(): LogsVerbosity;
    set verbosity(value: LogsVerbosity);
    setVerbosity(verbosity: Partial<LogsVerbosity> | Verbosity | undefined): void;
    get debug(): boolean;
    setDebug(debug: boolean | undefined): void;
}
export {};