using System.Numerics;
using Nethereum.ABI.FunctionEncoding.Attributes;
using Nethereum.Contracts;

namespace Managing.ABI.GmxV2.Multicall3.ContractDefinition
{
    public partial class Multicall3Deployment : Multicall3DeploymentBase
    {
        public Multicall3Deployment() : base(BYTECODE)
        {
        }

        public Multicall3Deployment(string byteCode) : base(byteCode)
        {
        }
    }

    public class Multicall3DeploymentBase : ContractDeploymentMessage
    {
        public static string BYTECODE =
            " ";

        public Multicall3DeploymentBase() : base(BYTECODE)
        {
        }

        public Multicall3DeploymentBase(string byteCode) : base(byteCode)
        {
        }
    }

    public partial class AggregateFunction : AggregateFunctionBase
    {
    }

    [Function("aggregate", typeof(AggregateOutputDTO))]
    public class AggregateFunctionBase : FunctionMessage
    {
        [Parameter("tuple[]", "calls", 1)] public virtual List<Call> Calls { get; set; }
    }

    public partial class BlockAndAggregateFunction : BlockAndAggregateFunctionBase
    {
    }

    [Function("blockAndAggregate", typeof(BlockAndAggregateOutputDTO))]
    public class BlockAndAggregateFunctionBase : FunctionMessage
    {
        [Parameter("tuple[]", "calls", 1)] public virtual List<Call> Calls { get; set; }
    }

    public partial class GetBlockHashFunction : GetBlockHashFunctionBase
    {
    }

    [Function("getBlockHash", "bytes32")]
    public class GetBlockHashFunctionBase : FunctionMessage
    {
        [Parameter("uint256", "blockNumber", 1)]
        public virtual BigInteger BlockNumber { get; set; }
    }

    public partial class GetBlockNumberFunction : GetBlockNumberFunctionBase
    {
    }

    [Function("getBlockNumber", "uint256")]
    public class GetBlockNumberFunctionBase : FunctionMessage
    {
    }

    public partial class GetCurrentBlockCoinbaseFunction : GetCurrentBlockCoinbaseFunctionBase
    {
    }

    [Function("getCurrentBlockCoinbase", "address")]
    public class GetCurrentBlockCoinbaseFunctionBase : FunctionMessage
    {
    }

    public partial class GetCurrentBlockDifficultyFunction : GetCurrentBlockDifficultyFunctionBase
    {
    }

    [Function("getCurrentBlockDifficulty", "uint256")]
    public class GetCurrentBlockDifficultyFunctionBase : FunctionMessage
    {
    }

    public partial class GetCurrentBlockGasLimitFunction : GetCurrentBlockGasLimitFunctionBase
    {
    }

    [Function("getCurrentBlockGasLimit", "uint256")]
    public class GetCurrentBlockGasLimitFunctionBase : FunctionMessage
    {
    }

    public partial class GetCurrentBlockTimestampFunction : GetCurrentBlockTimestampFunctionBase
    {
    }

    [Function("getCurrentBlockTimestamp", "uint256")]
    public class GetCurrentBlockTimestampFunctionBase : FunctionMessage
    {
    }

    public partial class GetEthBalanceFunction : GetEthBalanceFunctionBase
    {
    }

    [Function("getEthBalance", "uint256")]
    public class GetEthBalanceFunctionBase : FunctionMessage
    {
        [Parameter("address", "addr", 1)] public virtual string Addr { get; set; }
    }

    public partial class GetL1BlockNumberFunction : GetL1BlockNumberFunctionBase
    {
    }

    [Function("getL1BlockNumber", "uint256")]
    public class GetL1BlockNumberFunctionBase : FunctionMessage
    {
    }

    public partial class GetLastBlockHashFunction : GetLastBlockHashFunctionBase
    {
    }

    [Function("getLastBlockHash", "bytes32")]
    public class GetLastBlockHashFunctionBase : FunctionMessage
    {
    }

    public partial class TryAggregateFunction : TryAggregateFunctionBase
    {
    }

    [Function("tryAggregate", typeof(TryAggregateOutputDTO))]
    public class TryAggregateFunctionBase : FunctionMessage
    {
        [Parameter("bool", "requireSuccess", 1)]
        public virtual bool RequireSuccess { get; set; }

        [Parameter("tuple[]", "calls", 2)] public virtual List<Call> Calls { get; set; }
    }

    public partial class TryBlockAndAggregateFunction : TryBlockAndAggregateFunctionBase
    {
    }

    [Function("tryBlockAndAggregate", typeof(TryBlockAndAggregateOutputDTO))]
    public class TryBlockAndAggregateFunctionBase : FunctionMessage
    {
        [Parameter("bool", "requireSuccess", 1)]
        public virtual bool RequireSuccess { get; set; }

        [Parameter("tuple[]", "calls", 2)] public virtual List<Call> Calls { get; set; }
    }

    public partial class AggregateOutputDTO : AggregateOutputDTOBase
    {
    }

    [FunctionOutput]
    public class AggregateOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("uint256", "blockNumber", 1)]
        public virtual BigInteger BlockNumber { get; set; }

        [Parameter("bytes[]", "returnData", 2)]
        public virtual List<byte[]> ReturnData { get; set; }
    }

    public partial class BlockAndAggregateOutputDTO : BlockAndAggregateOutputDTOBase
    {
    }

    [FunctionOutput]
    public class BlockAndAggregateOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("uint256", "blockNumber", 1)]
        public virtual BigInteger BlockNumber { get; set; }

        [Parameter("bytes32", "blockHash", 2)] public virtual byte[] BlockHash { get; set; }

        [Parameter("tuple[]", "returnData", 3)]
        public virtual List<Result> ReturnData { get; set; }
    }

    public partial class GetBlockHashOutputDTO : GetBlockHashOutputDTOBase
    {
    }

    [FunctionOutput]
    public class GetBlockHashOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("bytes32", "blockHash", 1)] public virtual byte[] BlockHash { get; set; }
    }

    public partial class GetBlockNumberOutputDTO : GetBlockNumberOutputDTOBase
    {
    }

    [FunctionOutput]
    public class GetBlockNumberOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("uint256", "blockNumber", 1)]
        public virtual BigInteger BlockNumber { get; set; }
    }

    public partial class GetCurrentBlockCoinbaseOutputDTO : GetCurrentBlockCoinbaseOutputDTOBase
    {
    }

    [FunctionOutput]
    public class GetCurrentBlockCoinbaseOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("address", "coinbase", 1)] public virtual string Coinbase { get; set; }
    }

    public partial class GetCurrentBlockDifficultyOutputDTO : GetCurrentBlockDifficultyOutputDTOBase
    {
    }

    [FunctionOutput]
    public class GetCurrentBlockDifficultyOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("uint256", "difficulty", 1)]
        public virtual BigInteger Difficulty { get; set; }
    }

    public partial class GetCurrentBlockGasLimitOutputDTO : GetCurrentBlockGasLimitOutputDTOBase
    {
    }

    [FunctionOutput]
    public class GetCurrentBlockGasLimitOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("uint256", "gaslimit", 1)] public virtual BigInteger Gaslimit { get; set; }
    }

    public partial class GetCurrentBlockTimestampOutputDTO : GetCurrentBlockTimestampOutputDTOBase
    {
    }

    [FunctionOutput]
    public class GetCurrentBlockTimestampOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("uint256", "timestamp", 1)] public virtual BigInteger Timestamp { get; set; }
    }

    public partial class GetEthBalanceOutputDTO : GetEthBalanceOutputDTOBase
    {
    }

    [FunctionOutput]
    public class GetEthBalanceOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("uint256", "balance", 1)] public virtual BigInteger Balance { get; set; }
    }

    public partial class GetL1BlockNumberOutputDTO : GetL1BlockNumberOutputDTOBase
    {
    }

    [FunctionOutput]
    public class GetL1BlockNumberOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("uint256", "l1BlockNumber", 1)]
        public virtual BigInteger L1BlockNumber { get; set; }
    }

    public partial class GetLastBlockHashOutputDTO : GetLastBlockHashOutputDTOBase
    {
    }

    [FunctionOutput]
    public class GetLastBlockHashOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("bytes32", "blockHash", 1)] public virtual byte[] BlockHash { get; set; }
    }

    public partial class TryAggregateOutputDTO : TryAggregateOutputDTOBase
    {
    }

    [FunctionOutput]
    public class TryAggregateOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("tuple[]", "returnData", 1)]
        public virtual List<Result> ReturnData { get; set; }
    }

    public partial class TryBlockAndAggregateOutputDTO : TryBlockAndAggregateOutputDTOBase
    {
    }

    [FunctionOutput]
    public class TryBlockAndAggregateOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("uint256", "blockNumber", 1)]
        public virtual BigInteger BlockNumber { get; set; }

        [Parameter("bytes32", "blockHash", 2)] public virtual byte[] BlockHash { get; set; }

        [Parameter("tuple[]", "returnData", 3)]
        public virtual List<Result> ReturnData { get; set; }
    }
}