import { type Address, type ErrorClass, type MarketId, UnknownDataError } from "@morpho-org/blue-sdk";
import type { Hex } from "viem";
import type { Operation, OperationType } from "./operations.js";
export declare class UnexpectedOperation extends Error {
    constructor(type: OperationType, chainId: number);
}
export declare class UnknownMarketError extends UnknownDataError {
    readonly marketId: MarketId;
    constructor(marketId: MarketId);
}
export declare class UnknownUserError extends UnknownDataError {
    readonly user: Address;
    constructor(user: Address);
}
export declare class UnknownPositionError extends UnknownDataError {
    readonly user: Address;
    readonly marketId: MarketId;
    constructor(user: Address, marketId: MarketId);
}
export declare class UnknownHoldingError extends UnknownDataError {
    readonly user: Address;
    readonly token: Address;
    constructor(user: Address, token: Address);
}
export declare class UnknownVaultError extends UnknownDataError {
    readonly vault: Address;
    constructor(vault: Address);
}
export declare class UnknownVaultMarketConfigError extends UnknownDataError {
    readonly vault: Address;
    readonly marketId: MarketId;
    constructor(vault: Address, marketId: MarketId);
}
export declare class UnknownVaultUserError extends UnknownDataError {
    readonly vault: Address;
    readonly user: Address;
    constructor(vault: Address, user: Address);
}
export declare class UnknownWrappedTokenError extends UnknownDataError {
    readonly token: Address;
    constructor(token: Address);
}
export declare class UnknownContractError extends UnknownDataError {
    readonly contract: Address;
    constructor(contract: Address);
}
export declare class UnknownAllowanceError extends UnknownDataError {
    readonly token: Address;
    readonly owner: Address;
    readonly spender: Address;
    constructor(token: Address, owner: Address, spender: Address);
}
export declare class NonZeroAllowanceError extends UnknownDataError {
    readonly token: Address;
    readonly owner: Address;
    readonly contract: string;
    readonly allowance: bigint;
    constructor(token: Address, owner: Address, contract: string, allowance: bigint);
}
export declare class UnknownEIP2612DataError extends UnknownDataError {
    readonly token: Address;
    readonly owner: Address;
    constructor(token: Address, owner: Address);
}
export declare class UnknownVaultPublicAllocatorConfigError extends UnknownDataError {
    readonly vault: Address;
    constructor(vault: Address);
}
export declare class UnknownVaultMarketPublicAllocatorConfigError extends UnknownDataError {
    readonly vault: Address;
    readonly marketId: MarketId;
    constructor(vault: Address, marketId: MarketId);
}
export declare class UnknownVaultV2AdapterError extends UnknownDataError {
    readonly adapter: Address;
    constructor(adapter: Address);
}
export declare class UnknownVaultV2Error extends UnknownDataError {
    readonly vault: Address;
    constructor(vault: Address);
}
export declare namespace Erc20Errors {
    class InsufficientBalance extends Error {
        readonly token: Address;
        readonly user: Address;
        constructor(token: Address, user: Address);
    }
    class InsufficientAllowance extends Error {
        readonly token: Address;
        readonly owner: Address;
        readonly spender: Address;
        constructor(token: Address, owner: Address, spender: Address);
    }
    class InvalidEIP2612Nonce extends Error {
        readonly token: Address;
        readonly owner: Address;
        readonly nonce: bigint;
        constructor(token: Address, owner: Address, nonce: bigint);
    }
    class ExpiredEIP2612Signature extends Error {
        readonly token: Address;
        readonly owner: Address;
        readonly deadline: bigint;
        constructor(token: Address, owner: Address, deadline: bigint);
    }
    class InvalidPermit2Nonce extends Error {
        readonly token: Address;
        readonly owner: Address;
        readonly nonce: bigint;
        constructor(token: Address, owner: Address, nonce: bigint);
    }
    class ExpiredPermit2Signature extends Error {
        readonly token: Address;
        readonly owner: Address;
        readonly deadline: bigint;
        constructor(token: Address, owner: Address, deadline: bigint);
    }
    class InsufficientPermit2Allowance extends Error {
        readonly token: Address;
        readonly owner: Address;
        constructor(token: Address, owner: Address);
    }
    class UnauthorizedTransfer extends Error {
        readonly token: Address;
        readonly user: Address;
        constructor(token: Address, user: Address);
    }
}
export declare namespace SimulationErrors {
    class Simulation<T extends Operation = Operation> extends Error {
        readonly error: Error;
        readonly index: number;
        readonly operation: T;
        constructor(error: Error, index: number, operation: T);
    }
    class InvalidInput<T> extends Error {
        readonly input: T;
        constructor(input: T);
    }
}
export declare namespace BlueSimulationErrors {
    class MarketNotEnabled extends Error {
        readonly marketId: MarketId;
        constructor(marketId: MarketId);
    }
    class ZeroAssets extends Error {
        constructor();
    }
    class ZeroShares extends Error {
        constructor();
    }
    class UnauthorizedBundler extends Error {
        readonly user: Address;
        constructor(user: Address);
    }
}
export declare namespace MetaMorphoErrors {
    class ZeroAssets extends Error {
        constructor();
    }
    class ZeroShares extends Error {
        constructor();
    }
    class NotAllocatorRole extends Error {
        readonly vault: Address;
        readonly account: Address;
        constructor(vault: Address, account: Address);
    }
    class NotEnoughLiquidity extends Error {
        readonly vault: Address;
        readonly remainingRequested: bigint;
        constructor(vault: Address, remainingRequested: bigint);
    }
    class MarketNotEnabled extends Error {
        readonly vault: Address;
        readonly marketId: MarketId;
        constructor(vault: Address, marketId: MarketId);
    }
    class UnauthorizedMarket extends Error {
        readonly vault: Address;
        readonly marketId: MarketId;
        constructor(vault: Address, marketId: MarketId);
    }
    class SupplyCapExceeded extends Error {
        readonly vault: Address;
        readonly marketId: MarketId;
        readonly cap: bigint;
        constructor(vault: Address, marketId: MarketId, cap: bigint);
    }
    class AllCapsReached extends Error {
        readonly vault: Address;
        readonly remainingRequested: bigint;
        constructor(vault: Address, remainingRequested: bigint);
    }
    class InconsistentReallocation extends Error {
        readonly vault: Address;
        readonly totalSupplied: bigint;
        readonly totalWithdrawn: bigint;
        constructor(vault: Address, totalSupplied: bigint, totalWithdrawn: bigint);
    }
}
export declare namespace PublicAllocatorErrors {
    class WithdrawZero extends Error {
        readonly vault: Address;
        readonly marketId: MarketId;
        constructor(vault: Address, marketId: MarketId);
    }
    class EmptyWithdrawals extends Error {
        readonly vault: Address;
        constructor(vault: Address);
    }
    class InconsistentWithdrawals extends Error {
        readonly vault: Address;
        readonly prevId: MarketId;
        readonly nextId: MarketId;
        constructor(vault: Address, prevId: MarketId, nextId: MarketId);
    }
    class MaxOutflowExceeded extends Error {
        readonly vault: Address;
        readonly marketId: MarketId;
        constructor(vault: Address, marketId: MarketId);
    }
    class MaxInflowExceeded extends Error {
        readonly vault: Address;
        readonly marketId: MarketId;
        constructor(vault: Address, marketId: MarketId);
    }
    class DepositMarketInWithdrawals extends Error {
        readonly vault: Address;
        readonly supplyMarketId: MarketId;
        constructor(vault: Address, supplyMarketId: MarketId);
    }
    class NotEnoughSupply extends Error {
        readonly vault: Address;
        readonly marketId: MarketId;
        constructor(vault: Address, marketId: MarketId);
    }
}
export declare namespace ParaswapErrors {
    class InvalidOffset extends Error {
        readonly offset: number;
        readonly data: Hex;
        constructor(offset: number, data: Hex);
    }
    class ZeroAmount extends Error {
        constructor();
    }
}
export declare function getWrappedInstanceOf<E extends Error>(err: unknown, ...errorClasses: [ErrorClass<E>, ...ErrorClass<E>[]]): E | undefined;