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

namespace Managing.Tools.ABI.OrderBook.ContractDefinition
{
    public class OrderBookDeployment : OrderBookDeploymentBase
    {
        public OrderBookDeployment() : base(BYTECODE)
        {
        }

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

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

        public OrderBookDeploymentBase() : base(BYTECODE)
        {
        }

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

    public class PricePrecisionFunction : PricePrecisionFunctionBase
    {
    }

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

    public class UsdgPrecisionFunction : UsdgPrecisionFunctionBase
    {
    }

    [Function("USDG_PRECISION", "uint256")]
    public class UsdgPrecisionFunctionBase : FunctionMessage
    {
    }

    public class CancelDecreaseOrderFunction : CancelDecreaseOrderFunctionBase
    {
    }

    [Function("cancelDecreaseOrder")]
    public class CancelDecreaseOrderFunctionBase : FunctionMessage
    {
        [Parameter("uint256", "_orderIndex")]
        public virtual BigInteger OrderIndex { get; set; }
    }

    public class CancelIncreaseOrderFunction : CancelIncreaseOrderFunctionBase
    {
    }

    [Function("cancelIncreaseOrder")]
    public class CancelIncreaseOrderFunctionBase : FunctionMessage
    {
        [Parameter("uint256", "_orderIndex")]
        public virtual BigInteger OrderIndex { get; set; }
    }

    public class CancelMultipleFunction : CancelMultipleFunctionBase
    {
    }

    [Function("cancelMultiple")]
    public class CancelMultipleFunctionBase : FunctionMessage
    {
        [Parameter("uint256[]", "_swapOrderIndexes")]
        public virtual List<BigInteger> SwapOrderIndexes { get; set; }

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

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

    public class CancelSwapOrderFunction : CancelSwapOrderFunctionBase
    {
    }

    [Function("cancelSwapOrder")]
    public class CancelSwapOrderFunctionBase : FunctionMessage
    {
        [Parameter("uint256", "_orderIndex")]
        public virtual BigInteger OrderIndex { get; set; }
    }

    public class CreateDecreaseOrderFunction : CreateDecreaseOrderFunctionBase
    {
    }

    [Function("createDecreaseOrder")]
    public class CreateDecreaseOrderFunctionBase : FunctionMessage
    {
        [Parameter("address", "_indexToken")]
        public virtual string IndexToken { get; set; }

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

        [Parameter("address", "_collateralToken", 3)]
        public virtual string CollateralToken { get; set; }

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

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

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

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

    public class CreateIncreaseOrderFunction : CreateIncreaseOrderFunctionBase
    {
    }

    [Function("createIncreaseOrder")]
    public class CreateIncreaseOrderFunctionBase : FunctionMessage
    {
        [Parameter("address[]", "_path")] public virtual List<string> Path { get; set; }
        [Parameter("uint256", "_amountIn", 2)] public virtual BigInteger AmountIn { get; set; }

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

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

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

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

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

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

        [Parameter("bool", "_triggerAboveThreshold", 9)]
        public virtual bool TriggerAboveThreshold { get; set; }

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

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

    public class CreateSwapOrderFunction : CreateSwapOrderFunctionBase
    {
    }

    [Function("createSwapOrder")]
    public class CreateSwapOrderFunctionBase : FunctionMessage
    {
        [Parameter("address[]", "_path")] public virtual List<string> Path { get; set; }
        [Parameter("uint256", "_amountIn", 2)] public virtual BigInteger AmountIn { get; set; }
        [Parameter("uint256", "_minOut", 3)] public virtual BigInteger MinOut { get; set; }

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

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

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

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

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

    public class DecreaseOrdersFunction : DecreaseOrdersFunctionBase
    {
    }

    [Function("decreaseOrders", typeof(DecreaseOrdersOutputDTO))]
    public class DecreaseOrdersFunctionBase : FunctionMessage
    {
        [Parameter("address", "")] public virtual string ReturnValue1 { get; set; }
        [Parameter("uint256", "", 2)] public virtual BigInteger ReturnValue2 { get; set; }
    }

    public class DecreaseOrdersIndexFunction : DecreaseOrdersIndexFunctionBase
    {
    }

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

    public class ExecuteDecreaseOrderFunction : ExecuteDecreaseOrderFunctionBase
    {
    }

    [Function("executeDecreaseOrder")]
    public class ExecuteDecreaseOrderFunctionBase : FunctionMessage
    {
        [Parameter("address", "_address")] public virtual string Address { get; set; }

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

        [Parameter("address", "_feeReceiver", 3)]
        public virtual string FeeReceiver { get; set; }
    }

    public class ExecuteIncreaseOrderFunction : ExecuteIncreaseOrderFunctionBase
    {
    }

    [Function("executeIncreaseOrder")]
    public class ExecuteIncreaseOrderFunctionBase : FunctionMessage
    {
        [Parameter("address", "_address")] public virtual string Address { get; set; }

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

        [Parameter("address", "_feeReceiver", 3)]
        public virtual string FeeReceiver { get; set; }
    }

    public class ExecuteSwapOrderFunction : ExecuteSwapOrderFunctionBase
    {
    }

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

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

        [Parameter("address", "_feeReceiver", 3)]
        public virtual string FeeReceiver { get; set; }
    }

    public class GetDecreaseOrderFunction : GetDecreaseOrderFunctionBase
    {
    }

    [Function("getDecreaseOrder", typeof(GetDecreaseOrderOutputDTO))]
    public class GetDecreaseOrderFunctionBase : FunctionMessage
    {
        [Parameter("address", "_account")] public virtual string Account { get; set; }

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

    public class GetIncreaseOrderFunction : GetIncreaseOrderFunctionBase
    {
    }

    [Function("getIncreaseOrder", typeof(GetIncreaseOrderOutputDTO))]
    public class GetIncreaseOrderFunctionBase : FunctionMessage
    {
        [Parameter("address", "_account")] public virtual string Account { get; set; }

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

    public class GetSwapOrderFunction : GetSwapOrderFunctionBase
    {
    }

    [Function("getSwapOrder", typeof(GetSwapOrderOutputDTO))]
    public class GetSwapOrderFunctionBase : FunctionMessage
    {
        [Parameter("address", "_account")] public virtual string Account { get; set; }

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

    public class GetUsdgMinPriceFunction : GetUsdgMinPriceFunctionBase
    {
    }

    [Function("getUsdgMinPrice", "uint256")]
    public class GetUsdgMinPriceFunctionBase : FunctionMessage
    {
        [Parameter("address", "_otherToken")]
        public virtual string OtherToken { get; set; }
    }

    public class GovFunction : GovFunctionBase
    {
    }

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

    public class IncreaseOrdersFunction : IncreaseOrdersFunctionBase
    {
    }

    [Function("increaseOrders", typeof(IncreaseOrdersOutputDTO))]
    public class IncreaseOrdersFunctionBase : FunctionMessage
    {
        [Parameter("address", "")] public virtual string ReturnValue1 { get; set; }
        [Parameter("uint256", "", 2)] public virtual BigInteger ReturnValue2 { get; set; }
    }

    public class IncreaseOrdersIndexFunction : IncreaseOrdersIndexFunctionBase
    {
    }

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

    public class InitializeFunction : InitializeFunctionBase
    {
    }

    [Function("initialize")]
    public class InitializeFunctionBase : FunctionMessage
    {
        [Parameter("address", "_router")] public virtual string Router { get; set; }
        [Parameter("address", "_vault", 2)] public virtual string Vault { get; set; }
        [Parameter("address", "_weth", 3)] public virtual string Weth { get; set; }
        [Parameter("address", "_usdg", 4)] public virtual string Usdg { get; set; }

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

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

    public class IsInitializedFunction : IsInitializedFunctionBase
    {
    }

    [Function("isInitialized", "bool")]
    public class IsInitializedFunctionBase : FunctionMessage
    {
    }

    public class MinExecutionFeeFunction : MinExecutionFeeFunctionBase
    {
    }

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

    public class MinPurchaseTokenAmountUsdFunction : MinPurchaseTokenAmountUsdFunctionBase
    {
    }

    [Function("minPurchaseTokenAmountUsd", "uint256")]
    public class MinPurchaseTokenAmountUsdFunctionBase : FunctionMessage
    {
    }

    public class RouterFunction : RouterFunctionBase
    {
    }

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

    public class SetGovFunction : SetGovFunctionBase
    {
    }

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

    public class SetMinExecutionFeeFunction : SetMinExecutionFeeFunctionBase
    {
    }

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

    public class SetMinPurchaseTokenAmountUsdFunction : SetMinPurchaseTokenAmountUsdFunctionBase
    {
    }

    [Function("setMinPurchaseTokenAmountUsd")]
    public class SetMinPurchaseTokenAmountUsdFunctionBase : FunctionMessage
    {
        [Parameter("uint256", "_minPurchaseTokenAmountUsd")]
        public virtual BigInteger MinPurchaseTokenAmountUsd { get; set; }
    }

    public class SwapOrdersFunction : SwapOrdersFunctionBase
    {
    }

    [Function("swapOrders", typeof(SwapOrdersOutputDTO))]
    public class SwapOrdersFunctionBase : FunctionMessage
    {
        [Parameter("address", "")] public virtual string ReturnValue1 { get; set; }
        [Parameter("uint256", "", 2)] public virtual BigInteger ReturnValue2 { get; set; }
    }

    public class SwapOrdersIndexFunction : SwapOrdersIndexFunctionBase
    {
    }

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

    public class UpdateDecreaseOrderFunction : UpdateDecreaseOrderFunctionBase
    {
    }

    [Function("updateDecreaseOrder")]
    public class UpdateDecreaseOrderFunctionBase : FunctionMessage
    {
        [Parameter("uint256", "_orderIndex")]
        public virtual BigInteger OrderIndex { get; set; }

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

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

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

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

    public class UpdateIncreaseOrderFunction : UpdateIncreaseOrderFunctionBase
    {
    }

    [Function("updateIncreaseOrder")]
    public class UpdateIncreaseOrderFunctionBase : FunctionMessage
    {
        [Parameter("uint256", "_orderIndex")]
        public virtual BigInteger OrderIndex { get; set; }

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

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

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

    public class UpdateSwapOrderFunction : UpdateSwapOrderFunctionBase
    {
    }

    [Function("updateSwapOrder")]
    public class UpdateSwapOrderFunctionBase : FunctionMessage
    {
        [Parameter("uint256", "_orderIndex")]
        public virtual BigInteger OrderIndex { get; set; }

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

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

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

    public class UsdgFunction : UsdgFunctionBase
    {
    }

    [Function("usdg", "address")]
    public class UsdgFunctionBase : FunctionMessage
    {
    }

    public class ValidatePositionOrderPriceFunction : ValidatePositionOrderPriceFunctionBase
    {
    }

    [Function("validatePositionOrderPrice", typeof(ValidatePositionOrderPriceOutputDTO))]
    public class ValidatePositionOrderPriceFunctionBase : FunctionMessage
    {
        [Parameter("bool", "_triggerAboveThreshold")]
        public virtual bool TriggerAboveThreshold { get; set; }

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

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

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

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

    public class
        ValidateSwapOrderPriceWithTriggerAboveThresholdFunction :
        ValidateSwapOrderPriceWithTriggerAboveThresholdFunctionBase
    {
    }

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

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

    public class VaultFunction : VaultFunctionBase
    {
    }

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

    public class WethFunction : WethFunctionBase
    {
    }

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

    public class CancelDecreaseOrderEventDTO : CancelDecreaseOrderEventDTOBase
    {
    }

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

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

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

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

        [Parameter("address", "indexToken", 5, false)]
        public virtual string IndexToken { 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", "triggerPrice", 8, false)]
        public virtual BigInteger TriggerPrice { get; set; }

        [Parameter("bool", "triggerAboveThreshold", 9, false)]
        public virtual bool TriggerAboveThreshold { get; set; }

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

    public class CancelIncreaseOrderEventDTO : CancelIncreaseOrderEventDTOBase
    {
    }

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

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

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

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

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

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

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

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

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

        [Parameter("bool", "triggerAboveThreshold", 10, false)]
        public virtual bool TriggerAboveThreshold { get; set; }

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

    public class CancelSwapOrderEventDTO : CancelSwapOrderEventDTOBase
    {
    }

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

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

        [Parameter("address[]", "path", 3, false)]
        public virtual List<string> Path { 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", "triggerRatio", 6, false)]
        public virtual BigInteger TriggerRatio { get; set; }

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

        [Parameter("bool", "shouldUnwrap", 8, false)]
        public virtual bool ShouldUnwrap { get; set; }

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

    public class CreateDecreaseOrderEventDTO : CreateDecreaseOrderEventDTOBase
    {
    }

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

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

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

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

        [Parameter("address", "indexToken", 5, false)]
        public virtual string IndexToken { 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", "triggerPrice", 8, false)]
        public virtual BigInteger TriggerPrice { get; set; }

        [Parameter("bool", "triggerAboveThreshold", 9, false)]
        public virtual bool TriggerAboveThreshold { get; set; }

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

    public class CreateIncreaseOrderEventDTO : CreateIncreaseOrderEventDTOBase
    {
    }

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

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

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

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

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

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

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

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

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

        [Parameter("bool", "triggerAboveThreshold", 10, false)]
        public virtual bool TriggerAboveThreshold { get; set; }

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

    public class CreateSwapOrderEventDTO : CreateSwapOrderEventDTOBase
    {
    }

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

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

        [Parameter("address[]", "path", 3, false)]
        public virtual List<string> Path { 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", "triggerRatio", 6, false)]
        public virtual BigInteger TriggerRatio { get; set; }

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

        [Parameter("bool", "shouldUnwrap", 8, false)]
        public virtual bool ShouldUnwrap { get; set; }

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

    public class ExecuteDecreaseOrderEventDTO : ExecuteDecreaseOrderEventDTOBase
    {
    }

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

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

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

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

        [Parameter("address", "indexToken", 5, false)]
        public virtual string IndexToken { 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", "triggerPrice", 8, false)]
        public virtual BigInteger TriggerPrice { get; set; }

        [Parameter("bool", "triggerAboveThreshold", 9, false)]
        public virtual bool TriggerAboveThreshold { get; set; }

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

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

    public class ExecuteIncreaseOrderEventDTO : ExecuteIncreaseOrderEventDTOBase
    {
    }

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

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

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

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

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

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

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

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

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

        [Parameter("bool", "triggerAboveThreshold", 10, false)]
        public virtual bool TriggerAboveThreshold { get; set; }

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

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

    public class ExecuteSwapOrderEventDTO : ExecuteSwapOrderEventDTOBase
    {
    }

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

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

        [Parameter("address[]", "path", 3, false)]
        public virtual List<string> Path { 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", "amountOut", 6, false)]
        public virtual BigInteger AmountOut { get; set; }

        [Parameter("uint256", "triggerRatio", 7, false)]
        public virtual BigInteger TriggerRatio { get; set; }

        [Parameter("bool", "triggerAboveThreshold", 8, false)]
        public virtual bool TriggerAboveThreshold { get; set; }

        [Parameter("bool", "shouldUnwrap", 9, false)]
        public virtual bool ShouldUnwrap { get; set; }

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

    public class InitializeEventDTO : InitializeEventDTOBase
    {
    }

    [Event("Initialize")]
    public class InitializeEventDTOBase : IEventDTO
    {
        [Parameter("address", "router", 1, false)]
        public virtual string Router { get; set; }

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

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

        [Parameter("address", "usdg", 4, false)]
        public virtual string Usdg { get; set; }

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

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

    public class UpdateDecreaseOrderEventDTO : UpdateDecreaseOrderEventDTOBase
    {
    }

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

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

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

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

        [Parameter("address", "indexToken", 5, false)]
        public virtual string IndexToken { 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", "triggerPrice", 8, false)]
        public virtual BigInteger TriggerPrice { get; set; }

        [Parameter("bool", "triggerAboveThreshold", 9, false)]
        public virtual bool TriggerAboveThreshold { get; set; }
    }

    public class UpdateGovEventDTO : UpdateGovEventDTOBase
    {
    }

    [Event("UpdateGov")]
    public class UpdateGovEventDTOBase : IEventDTO
    {
        [Parameter("address", "gov", 1, false)]
        public virtual string Gov { get; set; }
    }

    public class UpdateIncreaseOrderEventDTO : UpdateIncreaseOrderEventDTOBase
    {
    }

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

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

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

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

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

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

        [Parameter("uint256", "triggerPrice", 7, false)]
        public virtual BigInteger TriggerPrice { get; set; }

        [Parameter("bool", "triggerAboveThreshold", 8, false)]
        public virtual bool TriggerAboveThreshold { get; set; }
    }

    public class UpdateMinExecutionFeeEventDTO : UpdateMinExecutionFeeEventDTOBase
    {
    }

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

    public class UpdateMinPurchaseTokenAmountUsdEventDTO : UpdateMinPurchaseTokenAmountUsdEventDTOBase
    {
    }

    [Event("UpdateMinPurchaseTokenAmountUsd")]
    public class UpdateMinPurchaseTokenAmountUsdEventDTOBase : IEventDTO
    {
        [Parameter("uint256", "minPurchaseTokenAmountUsd", 1, false)]
        public virtual BigInteger MinPurchaseTokenAmountUsd { get; set; }
    }

    public class UpdateSwapOrderEventDTO : UpdateSwapOrderEventDTOBase
    {
    }

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

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

        [Parameter("address[]", "path", 3, false)]
        public virtual List<string> Path { 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", "triggerRatio", 6, false)]
        public virtual BigInteger TriggerRatio { get; set; }

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

        [Parameter("bool", "shouldUnwrap", 8, false)]
        public virtual bool ShouldUnwrap { get; set; }

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

    public class PricePrecisionOutputDTO : PricePrecisionOutputDTOBase
    {
    }

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

    public class UsdgPrecisionOutputDTO : UsdgPrecisionOutputDTOBase
    {
    }

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


    public class DecreaseOrdersOutputDTO : DecreaseOrdersOutputDTOBase
    {
    }

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

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

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

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

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

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

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

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

    public class DecreaseOrdersIndexOutputDTO : DecreaseOrdersIndexOutputDTOBase
    {
    }

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


    public class GetDecreaseOrderOutputDTO : GetDecreaseOrderOutputDTOBase
    {
    }

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

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

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

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

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

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

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

    public class GetIncreaseOrderOutputDTO : GetIncreaseOrderOutputDTOBase
    {
    }

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

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

        [Parameter("address", "collateralToken", 3)]
        public virtual string CollateralToken { get; set; }

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

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

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

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

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

    public class GetSwapOrderOutputDTO : GetSwapOrderOutputDTOBase
    {
    }

    [FunctionOutput]
    public class GetSwapOrderOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("address", "path0")] public virtual string Path0 { get; set; }
        [Parameter("address", "path1", 2)] public virtual string Path1 { get; set; }
        [Parameter("address", "path2", 3)] public virtual string Path2 { get; set; }
        [Parameter("uint256", "amountIn", 4)] public virtual BigInteger AmountIn { get; set; }
        [Parameter("uint256", "minOut", 5)] public virtual BigInteger MinOut { get; set; }

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

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

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

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

    public class GetUsdgMinPriceOutputDTO : GetUsdgMinPriceOutputDTOBase
    {
    }

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

    public class GovOutputDTO : GovOutputDTOBase
    {
    }

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

    public class IncreaseOrdersOutputDTO : IncreaseOrdersOutputDTOBase
    {
    }

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

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

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

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

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

        [Parameter("uint256", "sizeDelta", 6)] public virtual BigInteger SizeDelta { get; set; }
        [Parameter("bool", "isLong", 7)] public virtual bool IsLong { get; set; }

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

        [Parameter("bool", "triggerAboveThreshold", 9)]
        public virtual bool TriggerAboveThreshold { get; set; }

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

    public class IncreaseOrdersIndexOutputDTO : IncreaseOrdersIndexOutputDTOBase
    {
    }

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


    public class IsInitializedOutputDTO : IsInitializedOutputDTOBase
    {
    }

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

    public class MinExecutionFeeOutputDTO : MinExecutionFeeOutputDTOBase
    {
    }

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

    public class MinPurchaseTokenAmountUsdOutputDTO : MinPurchaseTokenAmountUsdOutputDTOBase
    {
    }

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

    public class RouterOutputDTO : RouterOutputDTOBase
    {
    }

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


    public class SwapOrdersOutputDTO : SwapOrdersOutputDTOBase
    {
    }

    [FunctionOutput]
    public class SwapOrdersOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("address", "account")] public virtual string Account { get; set; }
        [Parameter("uint256", "amountIn", 2)] public virtual BigInteger AmountIn { get; set; }
        [Parameter("uint256", "minOut", 3)] public virtual BigInteger MinOut { get; set; }

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

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

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

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

    public class SwapOrdersIndexOutputDTO : SwapOrdersIndexOutputDTOBase
    {
    }

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


    public class UsdgOutputDTO : UsdgOutputDTOBase
    {
    }

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

    public class ValidatePositionOrderPriceOutputDTO : ValidatePositionOrderPriceOutputDTOBase
    {
    }

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

    public class
        ValidateSwapOrderPriceWithTriggerAboveThresholdOutputDTO :
        ValidateSwapOrderPriceWithTriggerAboveThresholdOutputDTOBase
    {
    }

    [FunctionOutput]
    public class ValidateSwapOrderPriceWithTriggerAboveThresholdOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("bool", "")] public virtual bool 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; }
    }
}