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

namespace Managing.Tools.ABI.PositionRouter.ContractDefinition
{
    public class PositionRouterDeployment : PositionRouterDeploymentBase
    {
        public PositionRouterDeployment() : base(BYTECODE)
        {
        }

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

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

        public PositionRouterDeploymentBase() : base(BYTECODE)
        {
        }

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

        [Parameter("address", "_vault")] public virtual string Vault { get; set; }
        [Parameter("address", "_router", 2)] public virtual string Router { get; set; }
        [Parameter("address", "_weth", 3)] public virtual string Weth { get; set; }

        [Parameter("address", "_shortsTracker", 4)]
        public virtual string ShortsTracker { get; set; }

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

        [Parameter("uint256", "_minExecutionFee", 6)]
        public virtual BigInteger MinExecutionFee { get; set; }
    }

    public class BasisPointsDivisorFunction : BasisPointsDivisorFunctionBase
    {
    }

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

    public class AdminFunction : AdminFunctionBase
    {
    }

    [Function("admin", "address")]
    public class AdminFunctionBase : FunctionMessage
    {
    }

    public class ApproveFunction : ApproveFunctionBase
    {
    }

    [Function("approve")]
    public class ApproveFunctionBase : FunctionMessage
    {
        [Parameter("address", "_token")] public virtual string Token { get; set; }
        [Parameter("address", "_spender", 2)] public virtual string Spender { get; set; }
        [Parameter("uint256", "_amount", 3)] public virtual BigInteger Amount { get; set; }
    }

    public class CallbackGasLimitFunction : CallbackGasLimitFunctionBase
    {
    }

    [Function("callbackGasLimit", "uint256")]
    public class CallbackGasLimitFunctionBase : FunctionMessage
    {
    }

    public class CancelDecreasePositionFunction : CancelDecreasePositionFunctionBase
    {
    }

    [Function("cancelDecreasePosition", "bool")]
    public class CancelDecreasePositionFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "_key")] public virtual byte[] Key { get; set; }

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

    public class CancelIncreasePositionFunction : CancelIncreasePositionFunctionBase
    {
    }

    [Function("cancelIncreasePosition", "bool")]
    public class CancelIncreasePositionFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "_key")] public virtual byte[] Key { get; set; }

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

    public class CreateDecreasePositionFunction : CreateDecreasePositionFunctionBase
    {
    }

    [Function("createDecreasePosition", "bytes32")]
    public class CreateDecreasePositionFunctionBase : FunctionMessage
    {
        [Parameter("address[]", "_path")] public virtual List<string> Path { get; set; }

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

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

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

        [Parameter("bool", "_isLong", 5)] public virtual bool IsLong { get; set; }
        [Parameter("address", "_receiver", 6)] public virtual string Receiver { get; set; }

        [Parameter("uint256", "_acceptablePrice", 7)]
        public virtual BigInteger AcceptablePrice { get; set; }

        [Parameter("uint256", "_minOut", 8)] public virtual BigInteger MinOut { get; set; }

        [Parameter("uint256", "_executionFee", 9)]
        public virtual BigInteger ExecutionFee { get; set; }

        [Parameter("bool", "_withdrawETH", 10)]
        public virtual bool WithdrawETH { get; set; }

        [Parameter("address", "_callbackTarget", 11)]
        public virtual string CallbackTarget { get; set; }
    }

    public class CreateIncreasePositionFunction : CreateIncreasePositionFunctionBase
    {
    }

    [Function("createIncreasePosition", "bytes32")]
    public class CreateIncreasePositionFunctionBase : FunctionMessage
    {
        [Parameter("address[]", "_path")] public virtual List<string> Path { get; set; }

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

        [Parameter("uint256", "_amountIn", 3)] public virtual BigInteger AmountIn { get; set; }
        [Parameter("uint256", "_minOut", 4)] public virtual BigInteger MinOut { get; set; }

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

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

        [Parameter("uint256", "_acceptablePrice", 7)]
        public virtual BigInteger AcceptablePrice { get; set; }

        [Parameter("uint256", "_executionFee", 8)]
        public virtual BigInteger ExecutionFee { get; set; }

        [Parameter("bytes32", "_referralCode", 9)]
        public virtual byte[] ReferralCode { get; set; }

        [Parameter("address", "_callbackTarget", 10)]
        public virtual string CallbackTarget { get; set; }
    }

    public class CreateIncreasePositionETHFunction : CreateIncreasePositionETHFunctionBase
    {
    }

    [Function("createIncreasePositionETH", "bytes32")]
    public class CreateIncreasePositionETHFunctionBase : FunctionMessage
    {
        [Parameter("address[]", "_path")] public virtual List<string> Path { get; set; }

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

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

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

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

        [Parameter("uint256", "_acceptablePrice", 6)]
        public virtual BigInteger AcceptablePrice { get; set; }

        [Parameter("uint256", "_executionFee", 7)]
        public virtual BigInteger ExecutionFee { get; set; }

        [Parameter("bytes32", "_referralCode", 8)]
        public virtual byte[] ReferralCode { get; set; }

        [Parameter("address", "_callbackTarget", 9)]
        public virtual string CallbackTarget { get; set; }
    }

    public class DecreasePositionRequestKeysFunction : DecreasePositionRequestKeysFunctionBase
    {
    }

    [Function("decreasePositionRequestKeys", "bytes32")]
    public class DecreasePositionRequestKeysFunctionBase : FunctionMessage
    {
        [Parameter("uint256", "")] public virtual BigInteger ReturnValue1 { get; set; }
    }

    public class DecreasePositionRequestKeysStartFunction : DecreasePositionRequestKeysStartFunctionBase
    {
    }

    [Function("decreasePositionRequestKeysStart", "uint256")]
    public class DecreasePositionRequestKeysStartFunctionBase : FunctionMessage
    {
    }

    public class DecreasePositionRequestsFunction : DecreasePositionRequestsFunctionBase
    {
    }

    [Function("decreasePositionRequests", typeof(DecreasePositionRequestsOutputDTO))]
    public class DecreasePositionRequestsFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "")] public virtual byte[] ReturnValue1 { get; set; }
    }

    public class DecreasePositionsIndexFunction : DecreasePositionsIndexFunctionBase
    {
    }

    [Function("decreasePositionsIndex", "uint256")]
    public class DecreasePositionsIndexFunctionBase : FunctionMessage
    {
        [Parameter("address", "")] public virtual string ReturnValue1 { get; set; }
    }

    public class DepositFeeFunction : DepositFeeFunctionBase
    {
    }

    [Function("depositFee", "uint256")]
    public class DepositFeeFunctionBase : FunctionMessage
    {
    }

    public class ExecuteDecreasePositionFunction : ExecuteDecreasePositionFunctionBase
    {
    }

    [Function("executeDecreasePosition", "bool")]
    public class ExecuteDecreasePositionFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "_key")] public virtual byte[] Key { get; set; }

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

    public class ExecuteDecreasePositionsFunction : ExecuteDecreasePositionsFunctionBase
    {
    }

    [Function("executeDecreasePositions")]
    public class ExecuteDecreasePositionsFunctionBase : FunctionMessage
    {
        [Parameter("uint256", "_endIndex")] public virtual BigInteger EndIndex { get; set; }

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

    public class ExecuteIncreasePositionFunction : ExecuteIncreasePositionFunctionBase
    {
    }

    [Function("executeIncreasePosition", "bool")]
    public class ExecuteIncreasePositionFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "_key")] public virtual byte[] Key { get; set; }

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

    public class ExecuteIncreasePositionsFunction : ExecuteIncreasePositionsFunctionBase
    {
    }

    [Function("executeIncreasePositions")]
    public class ExecuteIncreasePositionsFunctionBase : FunctionMessage
    {
        [Parameter("uint256", "_endIndex")] public virtual BigInteger EndIndex { get; set; }

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

    public class FeeReservesFunction : FeeReservesFunctionBase
    {
    }

    [Function("feeReserves", "uint256")]
    public class FeeReservesFunctionBase : FunctionMessage
    {
        [Parameter("address", "")] public virtual string ReturnValue1 { get; set; }
    }

    public class GetDecreasePositionRequestPathFunction : GetDecreasePositionRequestPathFunctionBase
    {
    }

    [Function("getDecreasePositionRequestPath", "address[]")]
    public class GetDecreasePositionRequestPathFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "_key")] public virtual byte[] Key { get; set; }
    }

    public class GetIncreasePositionRequestPathFunction : GetIncreasePositionRequestPathFunctionBase
    {
    }

    [Function("getIncreasePositionRequestPath", "address[]")]
    public class GetIncreasePositionRequestPathFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "_key")] public virtual byte[] Key { get; set; }
    }

    public class GetRequestKeyFunction : GetRequestKeyFunctionBase
    {
    }

    [Function("getRequestKey", "bytes32")]
    public class GetRequestKeyFunctionBase : FunctionMessage
    {
        [Parameter("address", "_account")] public virtual string Account { get; set; }
        [Parameter("uint256", "_index", 2)] public virtual BigInteger Index { get; set; }
    }

    public class GetRequestQueueLengthsFunction : GetRequestQueueLengthsFunctionBase
    {
    }

    [Function("getRequestQueueLengths", typeof(GetRequestQueueLengthsOutputDTO))]
    public class GetRequestQueueLengthsFunctionBase : FunctionMessage
    {
    }

    public class GovFunction : GovFunctionBase
    {
    }

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

    public class IncreasePositionBufferBpsFunction : IncreasePositionBufferBpsFunctionBase
    {
    }

    [Function("increasePositionBufferBps", "uint256")]
    public class IncreasePositionBufferBpsFunctionBase : FunctionMessage
    {
    }

    public class IncreasePositionRequestKeysFunction : IncreasePositionRequestKeysFunctionBase
    {
    }

    [Function("increasePositionRequestKeys", "bytes32")]
    public class IncreasePositionRequestKeysFunctionBase : FunctionMessage
    {
        [Parameter("uint256", "")] public virtual BigInteger ReturnValue1 { get; set; }
    }

    public class IncreasePositionRequestKeysStartFunction : IncreasePositionRequestKeysStartFunctionBase
    {
    }

    [Function("increasePositionRequestKeysStart", "uint256")]
    public class IncreasePositionRequestKeysStartFunctionBase : FunctionMessage
    {
    }

    public class IncreasePositionRequestsFunction : IncreasePositionRequestsFunctionBase
    {
    }

    [Function("increasePositionRequests", typeof(IncreasePositionRequestsOutputDTO))]
    public class IncreasePositionRequestsFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "")] public virtual byte[] ReturnValue1 { get; set; }
    }

    public class IncreasePositionsIndexFunction : IncreasePositionsIndexFunctionBase
    {
    }

    [Function("increasePositionsIndex", "uint256")]
    public class IncreasePositionsIndexFunctionBase : FunctionMessage
    {
        [Parameter("address", "")] public virtual string ReturnValue1 { get; set; }
    }

    public class IsLeverageEnabledFunction : IsLeverageEnabledFunctionBase
    {
    }

    [Function("isLeverageEnabled", "bool")]
    public class IsLeverageEnabledFunctionBase : FunctionMessage
    {
    }

    public class IsPositionKeeperFunction : IsPositionKeeperFunctionBase
    {
    }

    [Function("isPositionKeeper", "bool")]
    public class IsPositionKeeperFunctionBase : FunctionMessage
    {
        [Parameter("address", "")] public virtual string ReturnValue1 { get; set; }
    }

    public class MaxGlobalLongSizesFunction : MaxGlobalLongSizesFunctionBase
    {
    }

    [Function("maxGlobalLongSizes", "uint256")]
    public class MaxGlobalLongSizesFunctionBase : FunctionMessage
    {
        [Parameter("address", "")] public virtual string ReturnValue1 { get; set; }
    }

    public class MaxGlobalShortSizesFunction : MaxGlobalShortSizesFunctionBase
    {
    }

    [Function("maxGlobalShortSizes", "uint256")]
    public class MaxGlobalShortSizesFunctionBase : FunctionMessage
    {
        [Parameter("address", "")] public virtual string ReturnValue1 { get; set; }
    }

    public class MaxTimeDelayFunction : MaxTimeDelayFunctionBase
    {
    }

    [Function("maxTimeDelay", "uint256")]
    public class MaxTimeDelayFunctionBase : FunctionMessage
    {
    }

    public class MinBlockDelayKeeperFunction : MinBlockDelayKeeperFunctionBase
    {
    }

    [Function("minBlockDelayKeeper", "uint256")]
    public class MinBlockDelayKeeperFunctionBase : FunctionMessage
    {
    }

    public class MinExecutionFeeFunction : MinExecutionFeeFunctionBase
    {
    }

    [Function("minExecutionFee", "uint256")]
    public class MinExecutionFeeFunctionBase : FunctionMessage
    {
    }

    public class MinTimeDelayPublicFunction : MinTimeDelayPublicFunctionBase
    {
    }

    [Function("minTimeDelayPublic", "uint256")]
    public class MinTimeDelayPublicFunctionBase : FunctionMessage
    {
    }

    public class ReferralStorageFunction : ReferralStorageFunctionBase
    {
    }

    [Function("referralStorage", "address")]
    public class ReferralStorageFunctionBase : FunctionMessage
    {
    }

    public class RouterFunction : RouterFunctionBase
    {
    }

    [Function("router", "address")]
    public class RouterFunctionBase : FunctionMessage
    {
    }

    public class SendValueFunction : SendValueFunctionBase
    {
    }

    [Function("sendValue")]
    public class SendValueFunctionBase : FunctionMessage
    {
        [Parameter("address", "_receiver")] public virtual string Receiver { get; set; }
        [Parameter("uint256", "_amount", 2)] public virtual BigInteger Amount { get; set; }
    }

    public class SetAdminFunction : SetAdminFunctionBase
    {
    }

    [Function("setAdmin")]
    public class SetAdminFunctionBase : FunctionMessage
    {
        [Parameter("address", "_admin")] public virtual string Admin { get; set; }
    }

    public class SetCallbackGasLimitFunction : SetCallbackGasLimitFunctionBase
    {
    }

    [Function("setCallbackGasLimit")]
    public class SetCallbackGasLimitFunctionBase : FunctionMessage
    {
        [Parameter("uint256", "_callbackGasLimit")]
        public virtual BigInteger CallbackGasLimit { get; set; }
    }

    public class SetDelayValuesFunction : SetDelayValuesFunctionBase
    {
    }

    [Function("setDelayValues")]
    public class SetDelayValuesFunctionBase : FunctionMessage
    {
        [Parameter("uint256", "_minBlockDelayKeeper")]
        public virtual BigInteger MinBlockDelayKeeper { get; set; }

        [Parameter("uint256", "_minTimeDelayPublic", 2)]
        public virtual BigInteger MinTimeDelayPublic { get; set; }

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

    public class SetDepositFeeFunction : SetDepositFeeFunctionBase
    {
    }

    [Function("setDepositFee")]
    public class SetDepositFeeFunctionBase : FunctionMessage
    {
        [Parameter("uint256", "_depositFee")]
        public virtual BigInteger DepositFee { get; set; }
    }

    public class SetGovFunction : SetGovFunctionBase
    {
    }

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

    public class SetIncreasePositionBufferBpsFunction : SetIncreasePositionBufferBpsFunctionBase
    {
    }

    [Function("setIncreasePositionBufferBps")]
    public class SetIncreasePositionBufferBpsFunctionBase : FunctionMessage
    {
        [Parameter("uint256", "_increasePositionBufferBps")]
        public virtual BigInteger IncreasePositionBufferBps { get; set; }
    }

    public class SetIsLeverageEnabledFunction : SetIsLeverageEnabledFunctionBase
    {
    }

    [Function("setIsLeverageEnabled")]
    public class SetIsLeverageEnabledFunctionBase : FunctionMessage
    {
        [Parameter("bool", "_isLeverageEnabled")]
        public virtual bool IsLeverageEnabled { get; set; }
    }

    public class SetMaxGlobalSizesFunction : SetMaxGlobalSizesFunctionBase
    {
    }

    [Function("setMaxGlobalSizes")]
    public class SetMaxGlobalSizesFunctionBase : FunctionMessage
    {
        [Parameter("address[]", "_tokens")] public virtual List<string> Tokens { get; set; }

        [Parameter("uint256[]", "_longSizes", 2)]
        public virtual List<BigInteger> LongSizes { get; set; }

        [Parameter("uint256[]", "_shortSizes", 3)]
        public virtual List<BigInteger> ShortSizes { get; set; }
    }

    public class SetMinExecutionFeeFunction : SetMinExecutionFeeFunctionBase
    {
    }

    [Function("setMinExecutionFee")]
    public class SetMinExecutionFeeFunctionBase : FunctionMessage
    {
        [Parameter("uint256", "_minExecutionFee")]
        public virtual BigInteger MinExecutionFee { get; set; }
    }

    public class SetPositionKeeperFunction : SetPositionKeeperFunctionBase
    {
    }

    [Function("setPositionKeeper")]
    public class SetPositionKeeperFunctionBase : FunctionMessage
    {
        [Parameter("address", "_account")] public virtual string Account { get; set; }
        [Parameter("bool", "_isActive", 2)] public virtual bool IsActive { get; set; }
    }

    public class SetReferralStorageFunction : SetReferralStorageFunctionBase
    {
    }

    [Function("setReferralStorage")]
    public class SetReferralStorageFunctionBase : FunctionMessage
    {
        [Parameter("address", "_referralStorage")]
        public virtual string ReferralStorage { get; set; }
    }

    public class SetRequestKeysStartValuesFunction : SetRequestKeysStartValuesFunctionBase
    {
    }

    [Function("setRequestKeysStartValues")]
    public class SetRequestKeysStartValuesFunctionBase : FunctionMessage
    {
        [Parameter("uint256", "_increasePositionRequestKeysStart")]
        public virtual BigInteger IncreasePositionRequestKeysStart { get; set; }

        [Parameter("uint256", "_decreasePositionRequestKeysStart", 2)]
        public virtual BigInteger DecreasePositionRequestKeysStart { get; set; }
    }

    public class ShortsTrackerFunction : ShortsTrackerFunctionBase
    {
    }

    [Function("shortsTracker", "address")]
    public class ShortsTrackerFunctionBase : FunctionMessage
    {
    }

    public class VaultFunction : VaultFunctionBase
    {
    }

    [Function("vault", "address")]
    public class VaultFunctionBase : FunctionMessage
    {
    }

    public class WethFunction : WethFunctionBase
    {
    }

    [Function("weth", "address")]
    public class WethFunctionBase : FunctionMessage
    {
    }

    public class WithdrawFeesFunction : WithdrawFeesFunctionBase
    {
    }

    [Function("withdrawFees")]
    public class WithdrawFeesFunctionBase : FunctionMessage
    {
        [Parameter("address", "_token")] public virtual string Token { get; set; }
        [Parameter("address", "_receiver", 2)] public virtual string Receiver { get; set; }
    }

    public class CallbackEventDTO : CallbackEventDTOBase
    {
    }

    [Event("Callback")]
    public class CallbackEventDTOBase : IEventDTO
    {
        [Parameter("address", "callbackTarget", 1, false)]
        public virtual string CallbackTarget { get; set; }

        [Parameter("bool", "success", 2, false)]
        public virtual bool Success { get; set; }
    }

    public class CancelDecreasePositionEventDTO : CancelDecreasePositionEventDTOBase
    {
    }

    [Event("CancelDecreasePosition")]
    public class CancelDecreasePositionEventDTOBase : IEventDTO
    {
        [Parameter("address", "account", 1, true)]
        public virtual string Account { get; set; }

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

        [Parameter("address", "indexToken", 3, false)]
        public virtual string IndexToken { get; set; }

        [Parameter("uint256", "collateralDelta", 4, false)]
        public virtual BigInteger CollateralDelta { get; set; }

        [Parameter("uint256", "sizeDelta", 5, false)]
        public virtual BigInteger SizeDelta { get; set; }

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

        [Parameter("address", "receiver", 7, false)]
        public virtual string Receiver { get; set; }

        [Parameter("uint256", "acceptablePrice", 8, false)]
        public virtual BigInteger AcceptablePrice { get; set; }

        [Parameter("uint256", "minOut", 9, false)]
        public virtual BigInteger MinOut { get; set; }

        [Parameter("uint256", "executionFee", 10, false)]
        public virtual BigInteger ExecutionFee { get; set; }

        [Parameter("uint256", "blockGap", 11, false)]
        public virtual BigInteger BlockGap { get; set; }

        [Parameter("uint256", "timeGap", 12, false)]
        public virtual BigInteger TimeGap { get; set; }
    }

    public class CancelIncreasePositionEventDTO : CancelIncreasePositionEventDTOBase
    {
    }

    [Event("CancelIncreasePosition")]
    public class CancelIncreasePositionEventDTOBase : IEventDTO
    {
        [Parameter("address", "account", 1, true)]
        public virtual string Account { get; set; }

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

        [Parameter("address", "indexToken", 3, false)]
        public virtual string IndexToken { get; set; }

        [Parameter("uint256", "amountIn", 4, false)]
        public virtual BigInteger AmountIn { get; set; }

        [Parameter("uint256", "minOut", 5, false)]
        public virtual BigInteger MinOut { get; set; }

        [Parameter("uint256", "sizeDelta", 6, false)]
        public virtual BigInteger SizeDelta { get; set; }

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

        [Parameter("uint256", "acceptablePrice", 8, false)]
        public virtual BigInteger AcceptablePrice { get; set; }

        [Parameter("uint256", "executionFee", 9, false)]
        public virtual BigInteger ExecutionFee { get; set; }

        [Parameter("uint256", "blockGap", 10, false)]
        public virtual BigInteger BlockGap { get; set; }

        [Parameter("uint256", "timeGap", 11, false)]
        public virtual BigInteger TimeGap { get; set; }
    }

    public class CreateDecreasePositionEventDTO : CreateDecreasePositionEventDTOBase
    {
    }

    [Event("CreateDecreasePosition")]
    public class CreateDecreasePositionEventDTOBase : IEventDTO
    {
        [Parameter("address", "account", 1, true)]
        public virtual string Account { get; set; }

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

        [Parameter("address", "indexToken", 3, false)]
        public virtual string IndexToken { get; set; }

        [Parameter("uint256", "collateralDelta", 4, false)]
        public virtual BigInteger CollateralDelta { get; set; }

        [Parameter("uint256", "sizeDelta", 5, false)]
        public virtual BigInteger SizeDelta { get; set; }

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

        [Parameter("address", "receiver", 7, false)]
        public virtual string Receiver { get; set; }

        [Parameter("uint256", "acceptablePrice", 8, false)]
        public virtual BigInteger AcceptablePrice { get; set; }

        [Parameter("uint256", "minOut", 9, false)]
        public virtual BigInteger MinOut { get; set; }

        [Parameter("uint256", "executionFee", 10, false)]
        public virtual BigInteger ExecutionFee { get; set; }

        [Parameter("uint256", "index", 11, false)]
        public virtual BigInteger Index { get; set; }

        [Parameter("uint256", "queueIndex", 12, false)]
        public virtual BigInteger QueueIndex { get; set; }

        [Parameter("uint256", "blockNumber", 13, false)]
        public virtual BigInteger BlockNumber { get; set; }

        [Parameter("uint256", "blockTime", 14, false)]
        public virtual BigInteger BlockTime { get; set; }
    }

    public class CreateIncreasePositionEventDTO : CreateIncreasePositionEventDTOBase
    {
    }

    [Event("CreateIncreasePosition")]
    public class CreateIncreasePositionEventDTOBase : IEventDTO
    {
        [Parameter("address", "account", 1, true)]
        public virtual string Account { get; set; }

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

        [Parameter("address", "indexToken", 3, false)]
        public virtual string IndexToken { get; set; }

        [Parameter("uint256", "amountIn", 4, false)]
        public virtual BigInteger AmountIn { get; set; }

        [Parameter("uint256", "minOut", 5, false)]
        public virtual BigInteger MinOut { get; set; }

        [Parameter("uint256", "sizeDelta", 6, false)]
        public virtual BigInteger SizeDelta { get; set; }

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

        [Parameter("uint256", "acceptablePrice", 8, false)]
        public virtual BigInteger AcceptablePrice { get; set; }

        [Parameter("uint256", "executionFee", 9, false)]
        public virtual BigInteger ExecutionFee { get; set; }

        [Parameter("uint256", "index", 10, false)]
        public virtual BigInteger Index { get; set; }

        [Parameter("uint256", "queueIndex", 11, false)]
        public virtual BigInteger QueueIndex { get; set; }

        [Parameter("uint256", "blockNumber", 12, false)]
        public virtual BigInteger BlockNumber { get; set; }

        [Parameter("uint256", "blockTime", 13, false)]
        public virtual BigInteger BlockTime { get; set; }

        [Parameter("uint256", "gasPrice", 14, false)]
        public virtual BigInteger GasPrice { get; set; }
    }

    public class DecreasePositionReferralEventDTO : DecreasePositionReferralEventDTOBase
    {
    }

    [Event("DecreasePositionReferral")]
    public class DecreasePositionReferralEventDTOBase : IEventDTO
    {
        [Parameter("address", "account", 1, false)]
        public virtual string Account { get; set; }

        [Parameter("uint256", "sizeDelta", 2, false)]
        public virtual BigInteger SizeDelta { get; set; }

        [Parameter("uint256", "marginFeeBasisPoints", 3, false)]
        public virtual BigInteger MarginFeeBasisPoints { get; set; }

        [Parameter("bytes32", "referralCode", 4, false)]
        public virtual byte[] ReferralCode { get; set; }

        [Parameter("address", "referrer", 5, false)]
        public virtual string Referrer { get; set; }
    }

    public class ExecuteDecreasePositionEventDTO : ExecuteDecreasePositionEventDTOBase
    {
    }

    [Event("ExecuteDecreasePosition")]
    public class ExecuteDecreasePositionEventDTOBase : IEventDTO
    {
        [Parameter("address", "account", 1, true)]
        public virtual string Account { get; set; }

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

        [Parameter("address", "indexToken", 3, false)]
        public virtual string IndexToken { get; set; }

        [Parameter("uint256", "collateralDelta", 4, false)]
        public virtual BigInteger CollateralDelta { get; set; }

        [Parameter("uint256", "sizeDelta", 5, false)]
        public virtual BigInteger SizeDelta { get; set; }

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

        [Parameter("address", "receiver", 7, false)]
        public virtual string Receiver { get; set; }

        [Parameter("uint256", "acceptablePrice", 8, false)]
        public virtual BigInteger AcceptablePrice { get; set; }

        [Parameter("uint256", "minOut", 9, false)]
        public virtual BigInteger MinOut { get; set; }

        [Parameter("uint256", "executionFee", 10, false)]
        public virtual BigInteger ExecutionFee { get; set; }

        [Parameter("uint256", "blockGap", 11, false)]
        public virtual BigInteger BlockGap { get; set; }

        [Parameter("uint256", "timeGap", 12, false)]
        public virtual BigInteger TimeGap { get; set; }
    }

    public class ExecuteIncreasePositionEventDTO : ExecuteIncreasePositionEventDTOBase
    {
    }

    [Event("ExecuteIncreasePosition")]
    public class ExecuteIncreasePositionEventDTOBase : IEventDTO
    {
        [Parameter("address", "account", 1, true)]
        public virtual string Account { get; set; }

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

        [Parameter("address", "indexToken", 3, false)]
        public virtual string IndexToken { get; set; }

        [Parameter("uint256", "amountIn", 4, false)]
        public virtual BigInteger AmountIn { get; set; }

        [Parameter("uint256", "minOut", 5, false)]
        public virtual BigInteger MinOut { get; set; }

        [Parameter("uint256", "sizeDelta", 6, false)]
        public virtual BigInteger SizeDelta { get; set; }

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

        [Parameter("uint256", "acceptablePrice", 8, false)]
        public virtual BigInteger AcceptablePrice { get; set; }

        [Parameter("uint256", "executionFee", 9, false)]
        public virtual BigInteger ExecutionFee { get; set; }

        [Parameter("uint256", "blockGap", 10, false)]
        public virtual BigInteger BlockGap { get; set; }

        [Parameter("uint256", "timeGap", 11, false)]
        public virtual BigInteger TimeGap { get; set; }
    }

    public class IncreasePositionReferralEventDTO : IncreasePositionReferralEventDTOBase
    {
    }

    [Event("IncreasePositionReferral")]
    public class IncreasePositionReferralEventDTOBase : IEventDTO
    {
        [Parameter("address", "account", 1, false)]
        public virtual string Account { get; set; }

        [Parameter("uint256", "sizeDelta", 2, false)]
        public virtual BigInteger SizeDelta { get; set; }

        [Parameter("uint256", "marginFeeBasisPoints", 3, false)]
        public virtual BigInteger MarginFeeBasisPoints { get; set; }

        [Parameter("bytes32", "referralCode", 4, false)]
        public virtual byte[] ReferralCode { get; set; }

        [Parameter("address", "referrer", 5, false)]
        public virtual string Referrer { get; set; }
    }

    public class SetAdminEventDTO : SetAdminEventDTOBase
    {
    }

    [Event("SetAdmin")]
    public class SetAdminEventDTOBase : IEventDTO
    {
        [Parameter("address", "admin", 1, false)]
        public virtual string Admin { get; set; }
    }

    public class SetCallbackGasLimitEventDTO : SetCallbackGasLimitEventDTOBase
    {
    }

    [Event("SetCallbackGasLimit")]
    public class SetCallbackGasLimitEventDTOBase : IEventDTO
    {
        [Parameter("uint256", "callbackGasLimit", 1, false)]
        public virtual BigInteger CallbackGasLimit { get; set; }
    }

    public class SetDelayValuesEventDTO : SetDelayValuesEventDTOBase
    {
    }

    [Event("SetDelayValues")]
    public class SetDelayValuesEventDTOBase : IEventDTO
    {
        [Parameter("uint256", "minBlockDelayKeeper", 1, false)]
        public virtual BigInteger MinBlockDelayKeeper { get; set; }

        [Parameter("uint256", "minTimeDelayPublic", 2, false)]
        public virtual BigInteger MinTimeDelayPublic { get; set; }

        [Parameter("uint256", "maxTimeDelay", 3, false)]
        public virtual BigInteger MaxTimeDelay { get; set; }
    }

    public class SetDepositFeeEventDTO : SetDepositFeeEventDTOBase
    {
    }

    [Event("SetDepositFee")]
    public class SetDepositFeeEventDTOBase : IEventDTO
    {
        [Parameter("uint256", "depositFee", 1, false)]
        public virtual BigInteger DepositFee { get; set; }
    }

    public class SetIncreasePositionBufferBpsEventDTO : SetIncreasePositionBufferBpsEventDTOBase
    {
    }

    [Event("SetIncreasePositionBufferBps")]
    public class SetIncreasePositionBufferBpsEventDTOBase : IEventDTO
    {
        [Parameter("uint256", "increasePositionBufferBps", 1, false)]
        public virtual BigInteger IncreasePositionBufferBps { get; set; }
    }

    public class SetIsLeverageEnabledEventDTO : SetIsLeverageEnabledEventDTOBase
    {
    }

    [Event("SetIsLeverageEnabled")]
    public class SetIsLeverageEnabledEventDTOBase : IEventDTO
    {
        [Parameter("bool", "isLeverageEnabled", 1, false)]
        public virtual bool IsLeverageEnabled { get; set; }
    }

    public class SetMaxGlobalSizesEventDTO : SetMaxGlobalSizesEventDTOBase
    {
    }

    [Event("SetMaxGlobalSizes")]
    public class SetMaxGlobalSizesEventDTOBase : IEventDTO
    {
        [Parameter("address[]", "tokens", 1, false)]
        public virtual List<string> Tokens { get; set; }

        [Parameter("uint256[]", "longSizes", 2, false)]
        public virtual List<BigInteger> LongSizes { get; set; }

        [Parameter("uint256[]", "shortSizes", 3, false)]
        public virtual List<BigInteger> ShortSizes { get; set; }
    }

    public class SetMinExecutionFeeEventDTO : SetMinExecutionFeeEventDTOBase
    {
    }

    [Event("SetMinExecutionFee")]
    public class SetMinExecutionFeeEventDTOBase : IEventDTO
    {
        [Parameter("uint256", "minExecutionFee", 1, false)]
        public virtual BigInteger MinExecutionFee { get; set; }
    }

    public class SetPositionKeeperEventDTO : SetPositionKeeperEventDTOBase
    {
    }

    [Event("SetPositionKeeper")]
    public class SetPositionKeeperEventDTOBase : IEventDTO
    {
        [Parameter("address", "account", 1, true)]
        public virtual string Account { get; set; }

        [Parameter("bool", "isActive", 2, false)]
        public virtual bool IsActive { get; set; }
    }

    public class SetReferralStorageEventDTO : SetReferralStorageEventDTOBase
    {
    }

    [Event("SetReferralStorage")]
    public class SetReferralStorageEventDTOBase : IEventDTO
    {
        [Parameter("address", "referralStorage", 1, false)]
        public virtual string ReferralStorage { get; set; }
    }

    public class SetRequestKeysStartValuesEventDTO : SetRequestKeysStartValuesEventDTOBase
    {
    }

    [Event("SetRequestKeysStartValues")]
    public class SetRequestKeysStartValuesEventDTOBase : IEventDTO
    {
        [Parameter("uint256", "increasePositionRequestKeysStart", 1, false)]
        public virtual BigInteger IncreasePositionRequestKeysStart { get; set; }

        [Parameter("uint256", "decreasePositionRequestKeysStart", 2, false)]
        public virtual BigInteger DecreasePositionRequestKeysStart { get; set; }
    }

    public class WithdrawFeesEventDTO : WithdrawFeesEventDTOBase
    {
    }

    [Event("WithdrawFees")]
    public class WithdrawFeesEventDTOBase : IEventDTO
    {
        [Parameter("address", "token", 1, false)]
        public virtual string Token { get; set; }

        [Parameter("address", "receiver", 2, false)]
        public virtual string Receiver { get; set; }

        [Parameter("uint256", "amount", 3, false)]
        public virtual BigInteger Amount { get; set; }
    }

    public class BasisPointsDivisorOutputDTO : BasisPointsDivisorOutputDTOBase
    {
    }

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

    public class AdminOutputDTO : AdminOutputDTOBase
    {
    }

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


    public class CallbackGasLimitOutputDTO : CallbackGasLimitOutputDTOBase
    {
    }

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


    public class DecreasePositionRequestKeysOutputDTO : DecreasePositionRequestKeysOutputDTOBase
    {
    }

    [FunctionOutput]
    public class DecreasePositionRequestKeysOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("bytes32", "")] public virtual byte[] ReturnValue1 { get; set; }
    }

    public class DecreasePositionRequestKeysStartOutputDTO : DecreasePositionRequestKeysStartOutputDTOBase
    {
    }

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

    public class DecreasePositionRequestsOutputDTO : DecreasePositionRequestsOutputDTOBase
    {
    }

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

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

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

        [Parameter("uint256", "sizeDelta", 4)] public virtual BigInteger SizeDelta { get; set; }
        [Parameter("bool", "isLong", 5)] public virtual bool IsLong { get; set; }
        [Parameter("address", "receiver", 6)] public virtual string Receiver { get; set; }

        [Parameter("uint256", "acceptablePrice", 7)]
        public virtual BigInteger AcceptablePrice { get; set; }

        [Parameter("uint256", "minOut", 8)] public virtual BigInteger MinOut { get; set; }

        [Parameter("uint256", "executionFee", 9)]
        public virtual BigInteger ExecutionFee { get; set; }

        [Parameter("uint256", "blockNumber", 10)]
        public virtual BigInteger BlockNumber { get; set; }

        [Parameter("uint256", "blockTime", 11)]
        public virtual BigInteger BlockTime { get; set; }

        [Parameter("bool", "withdrawETH", 12)] public virtual bool WithdrawETH { get; set; }

        [Parameter("address", "callbackTarget", 13)]
        public virtual string CallbackTarget { get; set; }
    }

    public class DecreasePositionsIndexOutputDTO : DecreasePositionsIndexOutputDTOBase
    {
    }

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

    public class DepositFeeOutputDTO : DepositFeeOutputDTOBase
    {
    }

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


    public class FeeReservesOutputDTO : FeeReservesOutputDTOBase
    {
    }

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

    public class GetDecreasePositionRequestPathOutputDTO : GetDecreasePositionRequestPathOutputDTOBase
    {
    }

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

    public class GetIncreasePositionRequestPathOutputDTO : GetIncreasePositionRequestPathOutputDTOBase
    {
    }

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

    public class GetRequestKeyOutputDTO : GetRequestKeyOutputDTOBase
    {
    }

    [FunctionOutput]
    public class GetRequestKeyOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("bytes32", "")] public virtual byte[] ReturnValue1 { get; set; }
    }

    public class GetRequestQueueLengthsOutputDTO : GetRequestQueueLengthsOutputDTOBase
    {
    }

    [FunctionOutput]
    public class GetRequestQueueLengthsOutputDTOBase : 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; }
        [Parameter("uint256", "", 4)] public virtual BigInteger ReturnValue4 { get; set; }
    }

    public class GovOutputDTO : GovOutputDTOBase
    {
    }

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

    public class IncreasePositionBufferBpsOutputDTO : IncreasePositionBufferBpsOutputDTOBase
    {
    }

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

    public class IncreasePositionRequestKeysOutputDTO : IncreasePositionRequestKeysOutputDTOBase
    {
    }

    [FunctionOutput]
    public class IncreasePositionRequestKeysOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("bytes32", "")] public virtual byte[] ReturnValue1 { get; set; }
    }

    public class IncreasePositionRequestKeysStartOutputDTO : IncreasePositionRequestKeysStartOutputDTOBase
    {
    }

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

    public class IncreasePositionRequestsOutputDTO : IncreasePositionRequestsOutputDTOBase
    {
    }

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

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

        [Parameter("uint256", "amountIn", 3)] public virtual BigInteger AmountIn { get; set; }
        [Parameter("uint256", "minOut", 4)] public virtual BigInteger MinOut { get; set; }
        [Parameter("uint256", "sizeDelta", 5)] public virtual BigInteger SizeDelta { get; set; }
        [Parameter("bool", "isLong", 6)] public virtual bool IsLong { get; set; }

        [Parameter("uint256", "acceptablePrice", 7)]
        public virtual BigInteger AcceptablePrice { get; set; }

        [Parameter("uint256", "executionFee", 8)]
        public virtual BigInteger ExecutionFee { get; set; }

        [Parameter("uint256", "blockNumber", 9)]
        public virtual BigInteger BlockNumber { get; set; }

        [Parameter("uint256", "blockTime", 10)]
        public virtual BigInteger BlockTime { get; set; }

        [Parameter("bool", "hasCollateralInETH", 11)]
        public virtual bool HasCollateralInETH { get; set; }

        [Parameter("address", "callbackTarget", 12)]
        public virtual string CallbackTarget { get; set; }
    }

    public class IncreasePositionsIndexOutputDTO : IncreasePositionsIndexOutputDTOBase
    {
    }

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

    public class IsLeverageEnabledOutputDTO : IsLeverageEnabledOutputDTOBase
    {
    }

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

    public class IsPositionKeeperOutputDTO : IsPositionKeeperOutputDTOBase
    {
    }

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

    public class MaxGlobalLongSizesOutputDTO : MaxGlobalLongSizesOutputDTOBase
    {
    }

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

    public class MaxGlobalShortSizesOutputDTO : MaxGlobalShortSizesOutputDTOBase
    {
    }

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

    public class MaxTimeDelayOutputDTO : MaxTimeDelayOutputDTOBase
    {
    }

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

    public class MinBlockDelayKeeperOutputDTO : MinBlockDelayKeeperOutputDTOBase
    {
    }

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

    public class MinExecutionFeeOutputDTO : MinExecutionFeeOutputDTOBase
    {
    }

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

    public class MinTimeDelayPublicOutputDTO : MinTimeDelayPublicOutputDTOBase
    {
    }

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

    public class ReferralStorageOutputDTO : ReferralStorageOutputDTOBase
    {
    }

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

    public class RouterOutputDTO : RouterOutputDTOBase
    {
    }

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


    public class ShortsTrackerOutputDTO : ShortsTrackerOutputDTOBase
    {
    }

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

    public class VaultOutputDTO : VaultOutputDTOBase
    {
    }

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

    public class WethOutputDTO : WethOutputDTOBase
    {
    }

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