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

namespace Managing.Tools.ABI.Reader.ContractDefinition
{
    public class ReaderDeployment : ReaderDeploymentBase
    {
        public ReaderDeployment() : base(BYTECODE)
        {
        }

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

    public class ReaderDeploymentBase : ContractDeploymentMessage
    {
        public static string BYTECODE =
            "[encoded data, 46180 characters]";

        public ReaderDeploymentBase() : base(BYTECODE)
        {
        }

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

    public class BasisPointsDivisorFunction : BasisPointsDivisorFunctionBase
    {
    }

    [Function("BASIS_POINTS_DIVISOR", "uint256")]
    public class BasisPointsDivisorFunctionBase : FunctionMessage
    {
    }

    public class PositionPropsLengthFunction : PositionPropsLengthFunctionBase
    {
    }

    [Function("POSITION_PROPS_LENGTH", "uint256")]
    public class PositionPropsLengthFunctionBase : FunctionMessage
    {
    }

    public class PricePrecisionFunction : PricePrecisionFunctionBase
    {
    }

    [Function("PRICE_PRECISION", "uint256")]
    public class PricePrecisionFunctionBase : FunctionMessage
    {
    }

    public class UsdgDecimalsFunction : UsdgDecimalsFunctionBase
    {
    }

    [Function("USDG_DECIMALS", "uint256")]
    public class UsdgDecimalsFunctionBase : FunctionMessage
    {
    }

    public class GetAmountOutFunction : GetAmountOutFunctionBase
    {
    }

    [Function("getAmountOut", typeof(GetAmountOutOutputDTO))]
    public class GetAmountOutFunctionBase : FunctionMessage
    {
        [Parameter("address", "_vault")] public virtual string Vault { get; set; }
        [Parameter("address", "_tokenIn", 2)] public virtual string TokenIn { get; set; }
        [Parameter("address", "_tokenOut", 3)] public virtual string TokenOut { get; set; }
        [Parameter("uint256", "_amountIn", 4)] public virtual BigInteger AmountIn { get; set; }
    }

    public class GetFeeBasisPointsFunction : GetFeeBasisPointsFunctionBase
    {
    }

    [Function("getFeeBasisPoints", typeof(GetFeeBasisPointsOutputDTO))]
    public class GetFeeBasisPointsFunctionBase : FunctionMessage
    {
        [Parameter("address", "_vault")] public virtual string Vault { get; set; }
        [Parameter("address", "_tokenIn", 2)] public virtual string TokenIn { get; set; }
        [Parameter("address", "_tokenOut", 3)] public virtual string TokenOut { get; set; }
        [Parameter("uint256", "_amountIn", 4)] public virtual BigInteger AmountIn { get; set; }
    }

    public class GetFeesFunction : GetFeesFunctionBase
    {
    }

    [Function("getFees", "uint256[]")]
    public class GetFeesFunctionBase : FunctionMessage
    {
        [Parameter("address", "_vault")] public virtual string Vault { get; set; }
        [Parameter("address[]", "_tokens", 2)] public virtual List<string> Tokens { get; set; }
    }

    public class GetFullVaultTokenInfoFunction : GetFullVaultTokenInfoFunctionBase
    {
    }

    [Function("getFullVaultTokenInfo", "uint256[]")]
    public class GetFullVaultTokenInfoFunctionBase : FunctionMessage
    {
        [Parameter("address", "_vault")] public virtual string Vault { get; set; }
        [Parameter("address", "_weth", 2)] public virtual string Weth { get; set; }

        [Parameter("uint256", "_usdgAmount", 3)]
        public virtual BigInteger UsdgAmount { get; set; }

        [Parameter("address[]", "_tokens", 4)] public virtual List<string> Tokens { get; set; }
    }

    public class GetFundingRatesFunction : GetFundingRatesFunctionBase
    {
    }

    [Function("getFundingRates", "uint256[]")]
    public class GetFundingRatesFunctionBase : FunctionMessage
    {
        [Parameter("address", "_vault")] public virtual string Vault { get; set; }
        [Parameter("address", "_weth", 2)] public virtual string Weth { get; set; }
        [Parameter("address[]", "_tokens", 3)] public virtual List<string> Tokens { get; set; }
    }

    public class GetMaxAmountInFunction : GetMaxAmountInFunctionBase
    {
    }

    [Function("getMaxAmountIn", "uint256")]
    public class GetMaxAmountInFunctionBase : FunctionMessage
    {
        [Parameter("address", "_vault")] public virtual string Vault { get; set; }
        [Parameter("address", "_tokenIn", 2)] public virtual string TokenIn { get; set; }
        [Parameter("address", "_tokenOut", 3)] public virtual string TokenOut { get; set; }
    }

    public class GetPairInfoFunction : GetPairInfoFunctionBase
    {
    }

    [Function("getPairInfo", "uint256[]")]
    public class GetPairInfoFunctionBase : FunctionMessage
    {
        [Parameter("address", "_factory")] public virtual string Factory { get; set; }
        [Parameter("address[]", "_tokens", 2)] public virtual List<string> Tokens { get; set; }
    }

    public class GetPositionsFunction : GetPositionsFunctionBase
    {
    }

    [Function("getPositions", "uint256[]")]
    public class GetPositionsFunctionBase : FunctionMessage
    {
        [Parameter("address", "_vault")] public virtual string Vault { get; set; }
        [Parameter("address", "_account", 2)] public virtual string Account { get; set; }

        [Parameter("address[]", "_collateralTokens", 3)]
        public virtual List<string> CollateralTokens { get; set; }

        [Parameter("address[]", "_indexTokens", 4)]
        public virtual List<string> IndexTokens { get; set; }

        [Parameter("bool[]", "_isLong", 5)] public virtual List<bool> IsLong { get; set; }
    }

    public class GetPricesFunction : GetPricesFunctionBase
    {
    }

    [Function("getPrices", "uint256[]")]
    public class GetPricesFunctionBase : FunctionMessage
    {
        [Parameter("address", "_priceFeed")]
        public virtual string PriceFeed { get; set; }

        [Parameter("address[]", "_tokens", 2)] public virtual List<string> Tokens { get; set; }
    }

    public class GetStakingInfoFunction : GetStakingInfoFunctionBase
    {
    }

    [Function("getStakingInfo", "uint256[]")]
    public class GetStakingInfoFunctionBase : FunctionMessage
    {
        [Parameter("address", "_account")] public virtual string Account { get; set; }

        [Parameter("address[]", "_yieldTrackers", 2)]
        public virtual List<string> YieldTrackers { get; set; }
    }

    public class GetTokenBalancesFunction : GetTokenBalancesFunctionBase
    {
    }

    [Function("getTokenBalances", "uint256[]")]
    public class GetTokenBalancesFunctionBase : FunctionMessage
    {
        [Parameter("address", "_account")] public virtual string Account { get; set; }
        [Parameter("address[]", "_tokens", 2)] public virtual List<string> Tokens { get; set; }
    }

    public class GetTokenBalancesWithSuppliesFunction : GetTokenBalancesWithSuppliesFunctionBase
    {
    }

    [Function("getTokenBalancesWithSupplies", "uint256[]")]
    public class GetTokenBalancesWithSuppliesFunctionBase : FunctionMessage
    {
        [Parameter("address", "_account")] public virtual string Account { get; set; }
        [Parameter("address[]", "_tokens", 2)] public virtual List<string> Tokens { get; set; }
    }

    public class GetTokenSupplyFunction : GetTokenSupplyFunctionBase
    {
    }

    [Function("getTokenSupply", "uint256")]
    public class GetTokenSupplyFunctionBase : FunctionMessage
    {
        [Parameter("address", "_token")] public virtual string Token { get; set; }

        [Parameter("address[]", "_excludedAccounts", 2)]
        public virtual List<string> ExcludedAccounts { get; set; }
    }

    public class GetTotalBalanceFunction : GetTotalBalanceFunctionBase
    {
    }

    [Function("getTotalBalance", "uint256")]
    public class GetTotalBalanceFunctionBase : FunctionMessage
    {
        [Parameter("address", "_token")] public virtual string Token { get; set; }

        [Parameter("address[]", "_accounts", 2)]
        public virtual List<string> Accounts { get; set; }
    }

    public class GetTotalStakedFunction : GetTotalStakedFunctionBase
    {
    }

    [Function("getTotalStaked", "uint256[]")]
    public class GetTotalStakedFunctionBase : FunctionMessage
    {
        [Parameter("address[]", "_yieldTokens")]
        public virtual List<string> YieldTokens { get; set; }
    }

    public class GetVaultTokenInfoFunction : GetVaultTokenInfoFunctionBase
    {
    }

    [Function("getVaultTokenInfo", "uint256[]")]
    public class GetVaultTokenInfoFunctionBase : FunctionMessage
    {
        [Parameter("address", "_vault")] public virtual string Vault { get; set; }
        [Parameter("address", "_weth", 2)] public virtual string Weth { get; set; }

        [Parameter("uint256", "_usdgAmount", 3)]
        public virtual BigInteger UsdgAmount { get; set; }

        [Parameter("address[]", "_tokens", 4)] public virtual List<string> Tokens { get; set; }
    }

    public class GetVaultTokenInfoV2Function : GetVaultTokenInfoV2FunctionBase
    {
    }

    [Function("getVaultTokenInfoV2", "uint256[]")]
    public class GetVaultTokenInfoV2FunctionBase : FunctionMessage
    {
        [Parameter("address", "_vault")] public virtual string Vault { get; set; }
        [Parameter("address", "_weth", 2)] public virtual string Weth { get; set; }

        [Parameter("uint256", "_usdgAmount", 3)]
        public virtual BigInteger UsdgAmount { get; set; }

        [Parameter("address[]", "_tokens", 4)] public virtual List<string> Tokens { get; set; }
    }

    public class GetVestingInfoFunction : GetVestingInfoFunctionBase
    {
    }

    [Function("getVestingInfo", "uint256[]")]
    public class GetVestingInfoFunctionBase : FunctionMessage
    {
        [Parameter("address", "_account")] public virtual string Account { get; set; }

        [Parameter("address[]", "_vesters", 2)]
        public virtual List<string> Vesters { get; set; }
    }

    public class GovFunction : GovFunctionBase
    {
    }

    [Function("gov", "address")]
    public class GovFunctionBase : FunctionMessage
    {
    }

    public class HasMaxGlobalShortSizesFunction : HasMaxGlobalShortSizesFunctionBase
    {
    }

    [Function("hasMaxGlobalShortSizes", "bool")]
    public class HasMaxGlobalShortSizesFunctionBase : FunctionMessage
    {
    }

    public class SetConfigFunction : SetConfigFunctionBase
    {
    }

    [Function("setConfig")]
    public class SetConfigFunctionBase : FunctionMessage
    {
        [Parameter("bool", "_hasMaxGlobalShortSizes")]
        public virtual bool HasMaxGlobalShortSizes { get; set; }
    }

    public class SetGovFunction : SetGovFunctionBase
    {
    }

    [Function("setGov")]
    public class SetGovFunctionBase : FunctionMessage
    {
        [Parameter("address", "_gov")] public virtual string Gov { get; set; }
    }

    public class BasisPointsDivisorOutputDTO : BasisPointsDivisorOutputDTOBase
    {
    }

    [FunctionOutput]
    public class BasisPointsDivisorOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("uint256", "")] public virtual BigInteger ReturnValue1 { get; set; }
    }

    public class PositionPropsLengthOutputDTO : PositionPropsLengthOutputDTOBase
    {
    }

    [FunctionOutput]
    public class PositionPropsLengthOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("uint256", "")] public virtual BigInteger ReturnValue1 { get; set; }
    }

    public class PricePrecisionOutputDTO : PricePrecisionOutputDTOBase
    {
    }

    [FunctionOutput]
    public class PricePrecisionOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("uint256", "")] public virtual BigInteger ReturnValue1 { get; set; }
    }

    public class UsdgDecimalsOutputDTO : UsdgDecimalsOutputDTOBase
    {
    }

    [FunctionOutput]
    public class UsdgDecimalsOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("uint256", "")] public virtual BigInteger ReturnValue1 { get; set; }
    }

    public class GetAmountOutOutputDTO : GetAmountOutOutputDTOBase
    {
    }

    [FunctionOutput]
    public class GetAmountOutOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("uint256", "")] public virtual BigInteger ReturnValue1 { get; set; }
        [Parameter("uint256", "", 2)] public virtual BigInteger ReturnValue2 { get; set; }
    }

    public class GetFeeBasisPointsOutputDTO : GetFeeBasisPointsOutputDTOBase
    {
    }

    [FunctionOutput]
    public class GetFeeBasisPointsOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("uint256", "")] public virtual BigInteger ReturnValue1 { get; set; }
        [Parameter("uint256", "", 2)] public virtual BigInteger ReturnValue2 { get; set; }
        [Parameter("uint256", "", 3)] public virtual BigInteger ReturnValue3 { get; set; }
    }

    public class GetFeesOutputDTO : GetFeesOutputDTOBase
    {
    }

    [FunctionOutput]
    public class GetFeesOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("uint256[]", "")] public virtual List<BigInteger> ReturnValue1 { get; set; }
    }

    public class GetFullVaultTokenInfoOutputDTO : GetFullVaultTokenInfoOutputDTOBase
    {
    }

    [FunctionOutput]
    public class GetFullVaultTokenInfoOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("uint256[]", "")] public virtual List<BigInteger> ReturnValue1 { get; set; }
    }

    public class GetFundingRatesOutputDTO : GetFundingRatesOutputDTOBase
    {
    }

    [FunctionOutput]
    public class GetFundingRatesOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("uint256[]", "")] public virtual List<BigInteger> ReturnValue1 { get; set; }
    }

    public class GetMaxAmountInOutputDTO : GetMaxAmountInOutputDTOBase
    {
    }

    [FunctionOutput]
    public class GetMaxAmountInOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("uint256", "")] public virtual BigInteger ReturnValue1 { get; set; }
    }

    public class GetPairInfoOutputDTO : GetPairInfoOutputDTOBase
    {
    }

    [FunctionOutput]
    public class GetPairInfoOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("uint256[]", "")] public virtual List<BigInteger> ReturnValue1 { get; set; }
    }

    public class GetPositionsOutputDTO : GetPositionsOutputDTOBase
    {
    }

    [FunctionOutput]
    public class GetPositionsOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("uint256[]", "")] public virtual List<BigInteger> ReturnValue1 { get; set; }
    }

    public class GetPricesOutputDTO : GetPricesOutputDTOBase
    {
    }

    [FunctionOutput]
    public class GetPricesOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("uint256[]", "")] public virtual List<BigInteger> ReturnValue1 { get; set; }
    }

    public class GetStakingInfoOutputDTO : GetStakingInfoOutputDTOBase
    {
    }

    [FunctionOutput]
    public class GetStakingInfoOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("uint256[]", "")] public virtual List<BigInteger> ReturnValue1 { get; set; }
    }

    public class GetTokenBalancesOutputDTO : GetTokenBalancesOutputDTOBase
    {
    }

    [FunctionOutput]
    public class GetTokenBalancesOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("uint256[]", "")] public virtual List<BigInteger> ReturnValue1 { get; set; }
    }

    public class GetTokenBalancesWithSuppliesOutputDTO : GetTokenBalancesWithSuppliesOutputDTOBase
    {
    }

    [FunctionOutput]
    public class GetTokenBalancesWithSuppliesOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("uint256[]", "")] public virtual List<BigInteger> ReturnValue1 { get; set; }
    }

    public class GetTokenSupplyOutputDTO : GetTokenSupplyOutputDTOBase
    {
    }

    [FunctionOutput]
    public class GetTokenSupplyOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("uint256", "")] public virtual BigInteger ReturnValue1 { get; set; }
    }

    public class GetTotalBalanceOutputDTO : GetTotalBalanceOutputDTOBase
    {
    }

    [FunctionOutput]
    public class GetTotalBalanceOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("uint256", "")] public virtual BigInteger ReturnValue1 { get; set; }
    }

    public class GetTotalStakedOutputDTO : GetTotalStakedOutputDTOBase
    {
    }

    [FunctionOutput]
    public class GetTotalStakedOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("uint256[]", "")] public virtual List<BigInteger> ReturnValue1 { get; set; }
    }

    public class GetVaultTokenInfoOutputDTO : GetVaultTokenInfoOutputDTOBase
    {
    }

    [FunctionOutput]
    public class GetVaultTokenInfoOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("uint256[]", "")] public virtual List<BigInteger> ReturnValue1 { get; set; }
    }

    public class GetVaultTokenInfoV2OutputDTO : GetVaultTokenInfoV2OutputDTOBase
    {
    }

    [FunctionOutput]
    public class GetVaultTokenInfoV2OutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("uint256[]", "")] public virtual List<BigInteger> ReturnValue1 { get; set; }
    }

    public class GetVestingInfoOutputDTO : GetVestingInfoOutputDTOBase
    {
    }

    [FunctionOutput]
    public class GetVestingInfoOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("uint256[]", "")] public virtual List<BigInteger> ReturnValue1 { get; set; }
    }

    public class GovOutputDTO : GovOutputDTOBase
    {
    }

    [FunctionOutput]
    public class GovOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("address", "")] public virtual string ReturnValue1 { get; set; }
    }

    public class HasMaxGlobalShortSizesOutputDTO : HasMaxGlobalShortSizesOutputDTOBase
    {
    }

    [FunctionOutput]
    public class HasMaxGlobalShortSizesOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("bool", "")] public virtual bool ReturnValue1 { get; set; }
    }
}