using System.Numerics;
using Managing.ABI.GmxV2.Reader.ContractDefinition;
using Nethereum.ABI.FunctionEncoding.Attributes;
using Nethereum.Contracts;

namespace Managing.ABI.GmxV2.SyntheticsReader.ContractDefinition
{
    public partial class SyntheticsReaderDeployment : SyntheticsReaderDeploymentBase
    {
        public SyntheticsReaderDeployment() : base(BYTECODE)
        {
        }

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

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

        public SyntheticsReaderDeploymentBase() : base(BYTECODE)
        {
        }

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

    public partial class GetAccountOrdersFunction : GetAccountOrdersFunctionBase
    {
    }

    [Function("getAccountOrders", typeof(GetAccountOrdersOutputDTO))]
    public class GetAccountOrdersFunctionBase : FunctionMessage
    {
        [Parameter("address", "dataStore", 1)] public virtual string DataStore { get; set; }
        [Parameter("address", "account", 2)] public virtual string Account { get; set; }
        [Parameter("uint256", "start", 3)] public virtual BigInteger Start { get; set; }
        [Parameter("uint256", "end", 4)] public virtual BigInteger End { get; set; }
    }

    public partial class GetAccountPositionInfoListFunction : GetAccountPositionInfoListFunctionBase
    {
    }

    [Function("getAccountPositionInfoList", typeof(GetAccountPositionInfoListOutputDTO))]
    public class GetAccountPositionInfoListFunctionBase : FunctionMessage
    {
        [Parameter("address", "dataStore", 1)] public virtual string DataStore { get; set; }

        [Parameter("address", "referralStorage", 2)]
        public virtual string ReferralStorage { get; set; }

        [Parameter("address", "account", 3)] public virtual string Account { get; set; }
        [Parameter("address[]", "markets", 4)] public virtual List<string> Markets { get; set; }

        [Parameter("tuple[]", "marketPrices", 5)]
        public virtual List<MarketPrices> MarketPrices { get; set; }

        [Parameter("address", "uiFeeReceiver", 6)]
        public virtual string UiFeeReceiver { get; set; }

        [Parameter("uint256", "start", 7)] public virtual BigInteger Start { get; set; }
        [Parameter("uint256", "end", 8)] public virtual BigInteger End { get; set; }
    }

    public partial class GetAccountPositionsFunction : GetAccountPositionsFunctionBase
    {
    }

    [Function("getAccountPositions", typeof(GetAccountPositionsOutputDTO))]
    public class GetAccountPositionsFunctionBase : FunctionMessage
    {
        [Parameter("address", "dataStore", 1)] public virtual string DataStore { get; set; }
        [Parameter("address", "account", 2)] public virtual string Account { get; set; }
        [Parameter("uint256", "start", 3)] public virtual BigInteger Start { get; set; }
        [Parameter("uint256", "end", 4)] public virtual BigInteger End { get; set; }
    }

    public partial class GetAdlStateFunction : GetAdlStateFunctionBase
    {
    }

    [Function("getAdlState", typeof(GetAdlStateOutputDTO))]
    public class GetAdlStateFunctionBase : FunctionMessage
    {
        [Parameter("address", "dataStore", 1)] public virtual string DataStore { get; set; }
        [Parameter("address", "market", 2)] public virtual string Market { get; set; }
        [Parameter("bool", "isLong", 3)] public virtual bool IsLong { get; set; }
        [Parameter("tuple", "prices", 4)] public virtual MarketPrices Prices { get; set; }
    }

    public partial class GetDepositFunction : GetDepositFunctionBase
    {
    }

    [Function("getDeposit", typeof(GetDepositOutputDTO))]
    public class GetDepositFunctionBase : FunctionMessage
    {
        [Parameter("address", "dataStore", 1)] public virtual string DataStore { get; set; }
        [Parameter("bytes32", "key", 2)] public virtual byte[] Key { get; set; }
    }

    public partial class GetDepositAmountOutFunction : GetDepositAmountOutFunctionBase
    {
    }

    [Function("getDepositAmountOut", "uint256")]
    public class GetDepositAmountOutFunctionBase : FunctionMessage
    {
        [Parameter("address", "dataStore", 1)] public virtual string DataStore { get; set; }
        [Parameter("tuple", "market", 2)] public virtual MarketsProps Market { get; set; }
        [Parameter("tuple", "prices", 3)] public virtual MarketPrices Prices { get; set; }

        [Parameter("uint256", "longTokenAmount", 4)]
        public virtual BigInteger LongTokenAmount { get; set; }

        [Parameter("uint256", "shortTokenAmount", 5)]
        public virtual BigInteger ShortTokenAmount { get; set; }

        [Parameter("address", "uiFeeReceiver", 6)]
        public virtual string UiFeeReceiver { get; set; }

        [Parameter("uint8", "swapPricingType", 7)]
        public virtual byte SwapPricingType { get; set; }

        [Parameter("bool", "includeVirtualInventoryImpact", 8)]
        public virtual bool IncludeVirtualInventoryImpact { get; set; }
    }

    public partial class GetExecutionPriceFunction : GetExecutionPriceFunctionBase
    {
    }

    [Function("getExecutionPrice", typeof(GetExecutionPriceOutputDTO))]
    public class GetExecutionPriceFunctionBase : FunctionMessage
    {
        [Parameter("address", "dataStore", 1)] public virtual string DataStore { get; set; }
        [Parameter("address", "marketKey", 2)] public virtual string MarketKey { get; set; }

        [Parameter("tuple", "indexTokenPrice", 3)]
        public virtual Props IndexTokenPrice { get; set; }

        [Parameter("uint256", "positionSizeInUsd", 4)]
        public virtual BigInteger PositionSizeInUsd { get; set; }

        [Parameter("uint256", "positionSizeInTokens", 5)]
        public virtual BigInteger PositionSizeInTokens { get; set; }

        [Parameter("int256", "sizeDeltaUsd", 6)]
        public virtual BigInteger SizeDeltaUsd { get; set; }

        [Parameter("bool", "isLong", 7)] public virtual bool IsLong { get; set; }
    }

    public partial class GetMarketFunction : GetMarketFunctionBase
    {
    }

    [Function("getMarket", typeof(GetMarketOutputDTO))]
    public class GetMarketFunctionBase : FunctionMessage
    {
        [Parameter("address", "dataStore", 1)] public virtual string DataStore { get; set; }
        [Parameter("address", "key", 2)] public virtual string Key { get; set; }
    }

    public partial class GetMarketBySaltFunction : GetMarketBySaltFunctionBase
    {
    }

    [Function("getMarketBySalt", typeof(GetMarketBySaltOutputDTO))]
    public class GetMarketBySaltFunctionBase : FunctionMessage
    {
        [Parameter("address", "dataStore", 1)] public virtual string DataStore { get; set; }
        [Parameter("bytes32", "salt", 2)] public virtual byte[] Salt { get; set; }
    }

    public partial class GetMarketInfoFunction : GetMarketInfoFunctionBase
    {
    }

    [Function("getMarketInfo", typeof(GetMarketInfoOutputDTO))]
    public class GetMarketInfoFunctionBase : FunctionMessage
    {
        [Parameter("address", "dataStore", 1)] public virtual string DataStore { get; set; }
        [Parameter("tuple", "prices", 2)] public virtual MarketPrices Prices { get; set; }
        [Parameter("address", "marketKey", 3)] public virtual string MarketKey { get; set; }
    }

    public partial class GetMarketInfoListFunction : GetMarketInfoListFunctionBase
    {
    }

    [Function("getMarketInfoList", typeof(GetMarketInfoListOutputDTO))]
    public class GetMarketInfoListFunctionBase : FunctionMessage
    {
        [Parameter("address", "dataStore", 1)] public virtual string DataStore { get; set; }

        [Parameter("tuple[]", "marketPricesList", 2)]
        public virtual List<MarketPrices> MarketPricesList { get; set; }

        [Parameter("uint256", "start", 3)] public virtual BigInteger Start { get; set; }
        [Parameter("uint256", "end", 4)] public virtual BigInteger End { get; set; }
    }

    public partial class GetMarketTokenPriceFunction : GetMarketTokenPriceFunctionBase
    {
    }

    [Function("getMarketTokenPrice", typeof(GetMarketTokenPriceOutputDTO))]
    public class GetMarketTokenPriceFunctionBase : FunctionMessage
    {
        [Parameter("address", "dataStore", 1)] public virtual string DataStore { get; set; }
        [Parameter("tuple", "market", 2)] public virtual Props Market { get; set; }

        [Parameter("tuple", "indexTokenPrice", 3)]
        public virtual Props IndexTokenPrice { get; set; }

        [Parameter("tuple", "longTokenPrice", 4)]
        public virtual Props LongTokenPrice { get; set; }

        [Parameter("tuple", "shortTokenPrice", 5)]
        public virtual Props ShortTokenPrice { get; set; }

        [Parameter("bytes32", "pnlFactorType", 6)]
        public virtual byte[] PnlFactorType { get; set; }

        [Parameter("bool", "maximize", 7)] public virtual bool Maximize { get; set; }
    }

    public partial class GetMarketsFunction : GetMarketsFunctionBase
    {
    }

    [Function("getMarkets", typeof(GetMarketsOutputDTO))]
    public class GetMarketsFunctionBase : FunctionMessage
    {
        [Parameter("address", "dataStore", 1)] public virtual string DataStore { get; set; }
        [Parameter("uint256", "start", 2)] public virtual BigInteger Start { get; set; }
        [Parameter("uint256", "end", 3)] public virtual BigInteger End { get; set; }
    }

    public partial class GetNetPnlFunction : GetNetPnlFunctionBase
    {
    }

    [Function("getNetPnl", "int256")]
    public class GetNetPnlFunctionBase : FunctionMessage
    {
        [Parameter("address", "dataStore", 1)] public virtual string DataStore { get; set; }
        [Parameter("tuple", "market", 2)] public virtual Props Market { get; set; }

        [Parameter("tuple", "indexTokenPrice", 3)]
        public virtual Props IndexTokenPrice { get; set; }

        [Parameter("bool", "maximize", 4)] public virtual bool Maximize { get; set; }
    }

    public partial class GetOpenInterestWithPnlFunction : GetOpenInterestWithPnlFunctionBase
    {
    }

    [Function("getOpenInterestWithPnl", "int256")]
    public class GetOpenInterestWithPnlFunctionBase : FunctionMessage
    {
        [Parameter("address", "dataStore", 1)] public virtual string DataStore { get; set; }
        [Parameter("tuple", "market", 2)] public virtual Props Market { get; set; }

        [Parameter("tuple", "indexTokenPrice", 3)]
        public virtual Props IndexTokenPrice { get; set; }

        [Parameter("bool", "isLong", 4)] public virtual bool IsLong { get; set; }
        [Parameter("bool", "maximize", 5)] public virtual bool Maximize { get; set; }
    }

    public partial class GetOrderFunction : GetOrderFunctionBase
    {
    }

    [Function("getOrder", typeof(GetOrderOutputDTO))]
    public class GetOrderFunctionBase : FunctionMessage
    {
        [Parameter("address", "dataStore", 1)] public virtual string DataStore { get; set; }
        [Parameter("bytes32", "key", 2)] public virtual byte[] Key { get; set; }
    }

    public partial class GetPnlFunction : GetPnlFunctionBase
    {
    }

    [Function("getPnl", "int256")]
    public class GetPnlFunctionBase : FunctionMessage
    {
        [Parameter("address", "dataStore", 1)] public virtual string DataStore { get; set; }
        [Parameter("tuple", "market", 2)] public virtual Props Market { get; set; }

        [Parameter("tuple", "indexTokenPrice", 3)]
        public virtual Props IndexTokenPrice { get; set; }

        [Parameter("bool", "isLong", 4)] public virtual bool IsLong { get; set; }
        [Parameter("bool", "maximize", 5)] public virtual bool Maximize { get; set; }
    }

    public partial class GetPnlToPoolFactorFunction : GetPnlToPoolFactorFunctionBase
    {
    }

    [Function("getPnlToPoolFactor", "int256")]
    public class GetPnlToPoolFactorFunctionBase : FunctionMessage
    {
        [Parameter("address", "dataStore", 1)] public virtual string DataStore { get; set; }

        [Parameter("address", "marketAddress", 2)]
        public virtual string MarketAddress { get; set; }

        [Parameter("tuple", "prices", 3)] public virtual MarketPrices Prices { get; set; }
        [Parameter("bool", "isLong", 4)] public virtual bool IsLong { get; set; }
        [Parameter("bool", "maximize", 5)] public virtual bool Maximize { get; set; }
    }

    public partial class GetPositionFunction : GetPositionFunctionBase
    {
    }

    [Function("getPosition", typeof(GetPositionOutputDTO))]
    public class GetPositionFunctionBase : FunctionMessage
    {
        [Parameter("address", "dataStore", 1)] public virtual string DataStore { get; set; }
        [Parameter("bytes32", "key", 2)] public virtual byte[] Key { get; set; }
    }

    public partial class GetPositionInfoFunction : GetPositionInfoFunctionBase
    {
    }

    [Function("getPositionInfo", typeof(GetPositionInfoOutputDTO))]
    public class GetPositionInfoFunctionBase : FunctionMessage
    {
        [Parameter("address", "dataStore", 1)] public virtual string DataStore { get; set; }

        [Parameter("address", "referralStorage", 2)]
        public virtual string ReferralStorage { get; set; }

        [Parameter("bytes32", "positionKey", 3)]
        public virtual byte[] PositionKey { get; set; }

        [Parameter("tuple", "prices", 4)] public virtual MarketPrices Prices { get; set; }

        [Parameter("uint256", "sizeDeltaUsd", 5)]
        public virtual BigInteger SizeDeltaUsd { get; set; }

        [Parameter("address", "uiFeeReceiver", 6)]
        public virtual string UiFeeReceiver { get; set; }

        [Parameter("bool", "usePositionSizeAsSizeDeltaUsd", 7)]
        public virtual bool UsePositionSizeAsSizeDeltaUsd { get; set; }
    }

    public partial class GetPositionInfoListFunction : GetPositionInfoListFunctionBase
    {
    }

    [Function("getPositionInfoList", typeof(GetPositionInfoListOutputDTO))]
    public class GetPositionInfoListFunctionBase : FunctionMessage
    {
        [Parameter("address", "dataStore", 1)] public virtual string DataStore { get; set; }

        [Parameter("address", "referralStorage", 2)]
        public virtual string ReferralStorage { get; set; }

        [Parameter("bytes32[]", "positionKeys", 3)]
        public virtual List<byte[]> PositionKeys { get; set; }

        [Parameter("tuple[]", "prices", 4)] public virtual List<MarketPrices> Prices { get; set; }

        [Parameter("address", "uiFeeReceiver", 5)]
        public virtual string UiFeeReceiver { get; set; }
    }

    public partial class GetPositionPnlUsdFunction : GetPositionPnlUsdFunctionBase
    {
    }

    [Function("getPositionPnlUsd", typeof(GetPositionPnlUsdOutputDTO))]
    public class GetPositionPnlUsdFunctionBase : FunctionMessage
    {
        [Parameter("address", "dataStore", 1)] public virtual string DataStore { get; set; }
        [Parameter("tuple", "market", 2)] public virtual Props Market { get; set; }
        [Parameter("tuple", "prices", 3)] public virtual MarketPrices Prices { get; set; }

        [Parameter("bytes32", "positionKey", 4)]
        public virtual byte[] PositionKey { get; set; }

        [Parameter("uint256", "sizeDeltaUsd", 5)]
        public virtual BigInteger SizeDeltaUsd { get; set; }
    }

    public partial class GetShiftFunction : GetShiftFunctionBase
    {
    }

    [Function("getShift", typeof(GetShiftOutputDTO))]
    public class GetShiftFunctionBase : FunctionMessage
    {
        [Parameter("address", "dataStore", 1)] public virtual string DataStore { get; set; }
        [Parameter("bytes32", "key", 2)] public virtual byte[] Key { get; set; }
    }

    public partial class GetSwapAmountOutFunction : GetSwapAmountOutFunctionBase
    {
    }

    [Function("getSwapAmountOut", typeof(GetSwapAmountOutOutputDTO))]
    public class GetSwapAmountOutFunctionBase : FunctionMessage
    {
        [Parameter("address", "dataStore", 1)] public virtual string DataStore { get; set; }
        [Parameter("tuple", "market", 2)] public virtual Props Market { get; set; }
        [Parameter("tuple", "prices", 3)] public virtual MarketPrices Prices { get; set; }
        [Parameter("address", "tokenIn", 4)] public virtual string TokenIn { get; set; }
        [Parameter("uint256", "amountIn", 5)] public virtual BigInteger AmountIn { get; set; }

        [Parameter("address", "uiFeeReceiver", 6)]
        public virtual string UiFeeReceiver { get; set; }
    }

    public partial class GetSwapPriceImpactFunction : GetSwapPriceImpactFunctionBase
    {
    }

    [Function("getSwapPriceImpact", typeof(GetSwapPriceImpactOutputDTO))]
    public class GetSwapPriceImpactFunctionBase : FunctionMessage
    {
        [Parameter("address", "dataStore", 1)] public virtual string DataStore { get; set; }
        [Parameter("address", "marketKey", 2)] public virtual string MarketKey { get; set; }
        [Parameter("address", "tokenIn", 3)] public virtual string TokenIn { get; set; }
        [Parameter("address", "tokenOut", 4)] public virtual string TokenOut { get; set; }
        [Parameter("uint256", "amountIn", 5)] public virtual BigInteger AmountIn { get; set; }

        [Parameter("tuple", "tokenInPrice", 6)]
        public virtual Props TokenInPrice { get; set; }

        [Parameter("tuple", "tokenOutPrice", 7)]
        public virtual Props TokenOutPrice { get; set; }
    }

    public partial class GetWithdrawalFunction : GetWithdrawalFunctionBase
    {
    }

    [Function("getWithdrawal", typeof(GetWithdrawalOutputDTO))]
    public class GetWithdrawalFunctionBase : FunctionMessage
    {
        [Parameter("address", "dataStore", 1)] public virtual string DataStore { get; set; }
        [Parameter("bytes32", "key", 2)] public virtual byte[] Key { get; set; }
    }

    public partial class GetWithdrawalAmountOutFunction : GetWithdrawalAmountOutFunctionBase
    {
    }

    [Function("getWithdrawalAmountOut", typeof(GetWithdrawalAmountOutOutputDTO))]
    public class GetWithdrawalAmountOutFunctionBase : FunctionMessage
    {
        [Parameter("address", "dataStore", 1)] public virtual string DataStore { get; set; }
        [Parameter("tuple", "market", 2)] public virtual Props Market { get; set; }
        [Parameter("tuple", "prices", 3)] public virtual MarketPrices Prices { get; set; }

        [Parameter("uint256", "marketTokenAmount", 4)]
        public virtual BigInteger MarketTokenAmount { get; set; }

        [Parameter("address", "uiFeeReceiver", 5)]
        public virtual string UiFeeReceiver { get; set; }

        [Parameter("uint8", "swapPricingType", 6)]
        public virtual byte SwapPricingType { get; set; }
    }

    public partial class IsPositionLiquidatableFunction : IsPositionLiquidatableFunctionBase
    {
    }

    [Function("isPositionLiquidatable", typeof(IsPositionLiquidatableOutputDTO))]
    public class IsPositionLiquidatableFunctionBase : FunctionMessage
    {
        [Parameter("address", "dataStore", 1)] public virtual string DataStore { get; set; }

        [Parameter("address", "referralStorage", 2)]
        public virtual string ReferralStorage { get; set; }

        [Parameter("bytes32", "positionKey", 3)]
        public virtual byte[] PositionKey { get; set; }

        [Parameter("tuple", "market", 4)] public virtual Props Market { get; set; }
        [Parameter("tuple", "prices", 5)] public virtual MarketPrices Prices { get; set; }

        [Parameter("bool", "shouldValidateMinCollateralUsd", 6)]
        public virtual bool ShouldValidateMinCollateralUsd { get; set; }
    }

    public partial class GetAccountOrdersOutputDTO : GetAccountOrdersOutputDTOBase
    {
    }

    [FunctionOutput]
    public class GetAccountOrdersOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("tuple[]", "", 1)] public virtual List<Props> ReturnValue1 { get; set; }
    }

    public partial class GetAccountPositionInfoListOutputDTO : GetAccountPositionInfoListOutputDTOBase
    {
    }

    [FunctionOutput]
    public class GetAccountPositionInfoListOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("tuple[]", "", 1)] public virtual List<PositionInfo> ReturnValue1 { get; set; }
    }

    public partial class GetAccountPositionsOutputDTO : GetAccountPositionsOutputDTOBase
    {
    }

    [FunctionOutput]
    public class GetAccountPositionsOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("tuple[]", "", 1)] public virtual List<Props> ReturnValue1 { get; set; }
    }

    public partial class GetAdlStateOutputDTO : GetAdlStateOutputDTOBase
    {
    }

    [FunctionOutput]
    public class GetAdlStateOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("uint256", "", 1)] public virtual BigInteger ReturnValue1 { get; set; }
        [Parameter("bool", "", 2)] public virtual bool ReturnValue2 { get; set; }
        [Parameter("int256", "", 3)] public virtual BigInteger ReturnValue3 { get; set; }
        [Parameter("uint256", "", 4)] public virtual BigInteger ReturnValue4 { get; set; }
    }

    public partial class GetDepositOutputDTO : GetDepositOutputDTOBase
    {
    }

    [FunctionOutput]
    public class GetDepositOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("tuple", "", 1)] public virtual Props ReturnValue1 { get; set; }
    }

    public partial class GetDepositAmountOutOutputDTO : GetDepositAmountOutOutputDTOBase
    {
    }

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

    public partial class GetExecutionPriceOutputDTO : GetExecutionPriceOutputDTOBase
    {
    }

    [FunctionOutput]
    public class GetExecutionPriceOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("tuple", "", 1)] public virtual ExecutionPriceResult ReturnValue1 { get; set; }
    }

    public partial class GetMarketOutputDTO : GetMarketOutputDTOBase
    {
    }

    [FunctionOutput]
    public class GetMarketOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("tuple", "", 1)] public virtual Props ReturnValue1 { get; set; }
    }

    public partial class GetMarketBySaltOutputDTO : GetMarketBySaltOutputDTOBase
    {
    }

    [FunctionOutput]
    public class GetMarketBySaltOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("tuple", "", 1)] public virtual Props ReturnValue1 { get; set; }
    }

    public partial class GetMarketInfoOutputDTO : GetMarketInfoOutputDTOBase
    {
    }

    [FunctionOutput]
    public class GetMarketInfoOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("tuple", "", 1)] public virtual MarketInfo ReturnValue1 { get; set; }
    }

    public partial class GetMarketInfoListOutputDTO : GetMarketInfoListOutputDTOBase
    {
    }

    [FunctionOutput]
    public class GetMarketInfoListOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("tuple[]", "", 1)] public virtual List<MarketInfo> ReturnValue1 { get; set; }
    }

    public partial class GetMarketTokenPriceOutputDTO : GetMarketTokenPriceOutputDTOBase
    {
    }

    [FunctionOutput]
    public class GetMarketTokenPriceOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("int256", "", 1)] public virtual BigInteger ReturnValue1 { get; set; }
        [Parameter("tuple", "", 2)] public virtual Props ReturnValue2 { get; set; }
    }

    public partial class GetMarketsOutputDTO : GetMarketsOutputDTOBase
    {
    }

    [FunctionOutput]
    public class GetMarketsOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("tuple[]", "", 1)] public virtual List<Props> ReturnValue1 { get; set; }
    }

    public partial class GetNetPnlOutputDTO : GetNetPnlOutputDTOBase
    {
    }

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

    public partial class GetOpenInterestWithPnlOutputDTO : GetOpenInterestWithPnlOutputDTOBase
    {
    }

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

    public partial class GetOrderOutputDTO : GetOrderOutputDTOBase
    {
    }

    [FunctionOutput]
    public class GetOrderOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("tuple", "", 1)] public virtual Props ReturnValue1 { get; set; }
    }

    public partial class GetPnlOutputDTO : GetPnlOutputDTOBase
    {
    }

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

    public partial class GetPnlToPoolFactorOutputDTO : GetPnlToPoolFactorOutputDTOBase
    {
    }

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

    public partial class GetPositionOutputDTO : GetPositionOutputDTOBase
    {
    }

    [FunctionOutput]
    public class GetPositionOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("tuple", "", 1)] public virtual Props ReturnValue1 { get; set; }
    }

    public partial class GetPositionInfoOutputDTO : GetPositionInfoOutputDTOBase
    {
    }

    [FunctionOutput]
    public class GetPositionInfoOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("tuple", "", 1)] public virtual PositionInfo ReturnValue1 { get; set; }
    }

    public partial class GetPositionInfoListOutputDTO : GetPositionInfoListOutputDTOBase
    {
    }

    [FunctionOutput]
    public class GetPositionInfoListOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("tuple[]", "", 1)] public virtual List<PositionInfo> ReturnValue1 { get; set; }
    }

    public partial class GetPositionPnlUsdOutputDTO : GetPositionPnlUsdOutputDTOBase
    {
    }

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

    public partial class GetShiftOutputDTO : GetShiftOutputDTOBase
    {
    }

    [FunctionOutput]
    public class GetShiftOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("tuple", "", 1)] public virtual Props ReturnValue1 { get; set; }
    }

    public partial class GetSwapAmountOutOutputDTO : GetSwapAmountOutOutputDTOBase
    {
    }

    [FunctionOutput]
    public class GetSwapAmountOutOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("uint256", "", 1)] public virtual BigInteger ReturnValue1 { get; set; }
        [Parameter("int256", "", 2)] public virtual BigInteger ReturnValue2 { get; set; }
        [Parameter("tuple", "fees", 3)] public virtual SwapFees Fees { get; set; }
    }

    public partial class GetSwapPriceImpactOutputDTO : GetSwapPriceImpactOutputDTOBase
    {
    }

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

    public partial class GetWithdrawalOutputDTO : GetWithdrawalOutputDTOBase
    {
    }

    [FunctionOutput]
    public class GetWithdrawalOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("tuple", "", 1)] public virtual Props ReturnValue1 { get; set; }
    }

    public partial class GetWithdrawalAmountOutOutputDTO : GetWithdrawalAmountOutOutputDTOBase
    {
    }

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

    public partial class IsPositionLiquidatableOutputDTO : IsPositionLiquidatableOutputDTOBase
    {
    }

    [FunctionOutput]
    public class IsPositionLiquidatableOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("bool", "", 1)] public virtual bool ReturnValue1 { get; set; }
        [Parameter("string", "", 2)] public virtual string ReturnValue2 { get; set; }
        [Parameter("tuple", "", 3)] public virtual IsPositionLiquidatableInfo ReturnValue3 { get; set; }
    }
}