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

namespace Managing.ABI.GmxV2.ExchangeRouter.ContractDefinition
{
    public partial class ExchangeRouterDeployment : ExchangeRouterDeploymentBase
    {
        public ExchangeRouterDeployment() : base(BYTECODE)
        {
        }

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

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

        public ExchangeRouterDeploymentBase() : base(BYTECODE)
        {
        }

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

        [Parameter("address", "_router", 1)] public virtual string Router { get; set; }

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

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

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

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

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

        [Parameter("address", "_shiftHandler", 7)]
        public virtual string ShiftHandler { get; set; }

        [Parameter("address", "_orderHandler", 8)]
        public virtual string OrderHandler { get; set; }

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

    public partial class CancelDepositFunction : CancelDepositFunctionBase
    {
    }

    [Function("cancelDeposit")]
    public class CancelDepositFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "key", 1)] public virtual byte[] Key { get; set; }
    }

    public partial class CancelOrderFunction : CancelOrderFunctionBase
    {
    }

    [Function("cancelOrder")]
    public class CancelOrderFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "key", 1)] public virtual byte[] Key { get; set; }
    }

    public partial class CancelShiftFunction : CancelShiftFunctionBase
    {
    }

    [Function("cancelShift")]
    public class CancelShiftFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "key", 1)] public virtual byte[] Key { get; set; }
    }

    public partial class CancelWithdrawalFunction : CancelWithdrawalFunctionBase
    {
    }

    [Function("cancelWithdrawal")]
    public class CancelWithdrawalFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "key", 1)] public virtual byte[] Key { get; set; }
    }

    public partial class ClaimAffiliateRewardsFunction : ClaimAffiliateRewardsFunctionBase
    {
    }

    [Function("claimAffiliateRewards", "uint256[]")]
    public class ClaimAffiliateRewardsFunctionBase : FunctionMessage
    {
        [Parameter("address[]", "markets", 1)] public virtual List<string> Markets { get; set; }
        [Parameter("address[]", "tokens", 2)] public virtual List<string> Tokens { get; set; }
        [Parameter("address", "receiver", 3)] public virtual string Receiver { get; set; }
    }

    public partial class ClaimCollateralFunction : ClaimCollateralFunctionBase
    {
    }

    [Function("claimCollateral", "uint256[]")]
    public class ClaimCollateralFunctionBase : FunctionMessage
    {
        [Parameter("address[]", "markets", 1)] public virtual List<string> Markets { get; set; }
        [Parameter("address[]", "tokens", 2)] public virtual List<string> Tokens { get; set; }

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

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

    public partial class ClaimFundingFeesFunction : ClaimFundingFeesFunctionBase
    {
    }

    [Function("claimFundingFees", "uint256[]")]
    public class ClaimFundingFeesFunctionBase : FunctionMessage
    {
        [Parameter("address[]", "markets", 1)] public virtual List<string> Markets { get; set; }
        [Parameter("address[]", "tokens", 2)] public virtual List<string> Tokens { get; set; }
        [Parameter("address", "receiver", 3)] public virtual string Receiver { get; set; }
    }

    public partial class ClaimUiFeesFunction : ClaimUiFeesFunctionBase
    {
    }

    [Function("claimUiFees", "uint256[]")]
    public class ClaimUiFeesFunctionBase : FunctionMessage
    {
        [Parameter("address[]", "markets", 1)] public virtual List<string> Markets { get; set; }
        [Parameter("address[]", "tokens", 2)] public virtual List<string> Tokens { get; set; }
        [Parameter("address", "receiver", 3)] public virtual string Receiver { get; set; }
    }

    public partial class CreateDepositFunction : CreateDepositFunctionBase
    {
    }

    [Function("createDeposit", "bytes32")]
    public class CreateDepositFunctionBase : FunctionMessage
    {
        [Parameter("tuple", "params", 1)] public virtual CreateDepositParams Params { get; set; }
    }

    public partial class CreateOrderFunction : CreateOrderFunctionBase
    {
    }

    [Function("createOrder", "bytes32")]
    public class CreateOrderFunctionBase : FunctionMessage
    {
        [Parameter("tuple", "params", 1)] public virtual CreateOrderParams Params { get; set; }
    }

    public partial class CreateShiftFunction : CreateShiftFunctionBase
    {
    }

    [Function("createShift", "bytes32")]
    public class CreateShiftFunctionBase : FunctionMessage
    {
        [Parameter("tuple", "params", 1)] public virtual CreateShiftParams Params { get; set; }
    }

    public partial class CreateWithdrawalFunction : CreateWithdrawalFunctionBase
    {
    }

    [Function("createWithdrawal", "bytes32")]
    public class CreateWithdrawalFunctionBase : FunctionMessage
    {
        [Parameter("tuple", "params", 1)] public virtual CreateWithdrawalParams Params { get; set; }
    }

    public partial class DataStoreFunction : DataStoreFunctionBase
    {
    }

    [Function("dataStore", "address")]
    public class DataStoreFunctionBase : FunctionMessage
    {
    }

    public partial class DepositHandlerFunction : DepositHandlerFunctionBase
    {
    }

    [Function("depositHandler", "address")]
    public class DepositHandlerFunctionBase : FunctionMessage
    {
    }

    public partial class EventEmitterFunction : EventEmitterFunctionBase
    {
    }

    [Function("eventEmitter", "address")]
    public class EventEmitterFunctionBase : FunctionMessage
    {
    }

    public partial class ExecuteAtomicWithdrawalFunction : ExecuteAtomicWithdrawalFunctionBase
    {
    }

    [Function("executeAtomicWithdrawal")]
    public class ExecuteAtomicWithdrawalFunctionBase : FunctionMessage
    {
        [Parameter("tuple", "params", 1)] public virtual CreateWithdrawalParams Params { get; set; }

        [Parameter("tuple", "oracleParams", 2)]
        public virtual SetPricesParams OracleParams { get; set; }
    }

    public partial class ExternalHandlerFunction : ExternalHandlerFunctionBase
    {
    }

    [Function("externalHandler", "address")]
    public class ExternalHandlerFunctionBase : FunctionMessage
    {
    }

    public partial class MakeExternalCallsFunction : MakeExternalCallsFunctionBase
    {
    }

    [Function("makeExternalCalls")]
    public class MakeExternalCallsFunctionBase : FunctionMessage
    {
        [Parameter("address[]", "externalCallTargets", 1)]
        public virtual List<string> ExternalCallTargets { get; set; }

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

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

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

    public partial class MulticallFunction : MulticallFunctionBase
    {
    }

    [Function("multicall", "bytes[]")]
    public class MulticallFunctionBase : FunctionMessage
    {
        [Parameter("bytes[]", "data", 1)] public virtual List<byte[]> Data { get; set; }
    }

    public partial class OrderHandlerFunction : OrderHandlerFunctionBase
    {
    }

    [Function("orderHandler", "address")]
    public class OrderHandlerFunctionBase : FunctionMessage
    {
    }

    public partial class RoleStoreFunction : RoleStoreFunctionBase
    {
    }

    [Function("roleStore", "address")]
    public class RoleStoreFunctionBase : FunctionMessage
    {
    }

    public partial class RouterFunction : RouterFunctionBase
    {
    }

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

    public partial class SendNativeTokenFunction : SendNativeTokenFunctionBase
    {
    }

    [Function("sendNativeToken")]
    public class SendNativeTokenFunctionBase : FunctionMessage
    {
        [Parameter("address", "receiver", 1)] public virtual string Receiver { get; set; }
        [Parameter("uint256", "amount", 2)] public virtual BigInteger Amount { get; set; }
    }

    public partial class SendTokensFunction : SendTokensFunctionBase
    {
    }

    [Function("sendTokens")]
    public class SendTokensFunctionBase : FunctionMessage
    {
        [Parameter("address", "token", 1)] public virtual string Token { get; set; }
        [Parameter("address", "receiver", 2)] public virtual string Receiver { get; set; }
        [Parameter("uint256", "amount", 3)] public virtual BigInteger Amount { get; set; }
    }

    public partial class SendWntFunction : SendWntFunctionBase
    {
    }

    [Function("sendWnt")]
    public class SendWntFunctionBase : FunctionMessage
    {
        [Parameter("address", "receiver", 1)] public virtual string Receiver { get; set; }
        [Parameter("uint256", "amount", 2)] public virtual BigInteger Amount { get; set; }
    }

    public partial class SetSavedCallbackContractFunction : SetSavedCallbackContractFunctionBase
    {
    }

    [Function("setSavedCallbackContract")]
    public class SetSavedCallbackContractFunctionBase : FunctionMessage
    {
        [Parameter("address", "market", 1)] public virtual string Market { get; set; }

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

    public partial class SetUiFeeFactorFunction : SetUiFeeFactorFunctionBase
    {
    }

    [Function("setUiFeeFactor")]
    public class SetUiFeeFactorFunctionBase : FunctionMessage
    {
        [Parameter("uint256", "uiFeeFactor", 1)]
        public virtual BigInteger UiFeeFactor { get; set; }
    }

    public partial class ShiftHandlerFunction : ShiftHandlerFunctionBase
    {
    }

    [Function("shiftHandler", "address")]
    public class ShiftHandlerFunctionBase : FunctionMessage
    {
    }

    public partial class SimulateExecuteDepositFunction : SimulateExecuteDepositFunctionBase
    {
    }

    [Function("simulateExecuteDeposit")]
    public class SimulateExecuteDepositFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "key", 1)] public virtual byte[] Key { get; set; }

        [Parameter("tuple", "simulatedOracleParams", 2)]
        public virtual SimulatePricesParams SimulatedOracleParams { get; set; }
    }

    public partial class SimulateExecuteLatestDepositFunction : SimulateExecuteLatestDepositFunctionBase
    {
    }

    [Function("simulateExecuteLatestDeposit")]
    public class SimulateExecuteLatestDepositFunctionBase : FunctionMessage
    {
        [Parameter("tuple", "simulatedOracleParams", 1)]
        public virtual SimulatePricesParams SimulatedOracleParams { get; set; }
    }

    public partial class SimulateExecuteLatestOrderFunction : SimulateExecuteLatestOrderFunctionBase
    {
    }

    [Function("simulateExecuteLatestOrder")]
    public class SimulateExecuteLatestOrderFunctionBase : FunctionMessage
    {
        [Parameter("tuple", "simulatedOracleParams", 1)]
        public virtual SimulatePricesParams SimulatedOracleParams { get; set; }
    }

    public partial class SimulateExecuteLatestShiftFunction : SimulateExecuteLatestShiftFunctionBase
    {
    }

    [Function("simulateExecuteLatestShift")]
    public class SimulateExecuteLatestShiftFunctionBase : FunctionMessage
    {
        [Parameter("tuple", "simulatedOracleParams", 1)]
        public virtual SimulatePricesParams SimulatedOracleParams { get; set; }
    }

    public partial class SimulateExecuteLatestWithdrawalFunction : SimulateExecuteLatestWithdrawalFunctionBase
    {
    }

    [Function("simulateExecuteLatestWithdrawal")]
    public class SimulateExecuteLatestWithdrawalFunctionBase : FunctionMessage
    {
        [Parameter("tuple", "simulatedOracleParams", 1)]
        public virtual SimulatePricesParams SimulatedOracleParams { get; set; }

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

    public partial class SimulateExecuteOrderFunction : SimulateExecuteOrderFunctionBase
    {
    }

    [Function("simulateExecuteOrder")]
    public class SimulateExecuteOrderFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "key", 1)] public virtual byte[] Key { get; set; }

        [Parameter("tuple", "simulatedOracleParams", 2)]
        public virtual SimulatePricesParams SimulatedOracleParams { get; set; }
    }

    public partial class SimulateExecuteShiftFunction : SimulateExecuteShiftFunctionBase
    {
    }

    [Function("simulateExecuteShift")]
    public class SimulateExecuteShiftFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "key", 1)] public virtual byte[] Key { get; set; }

        [Parameter("tuple", "simulatedOracleParams", 2)]
        public virtual SimulatePricesParams SimulatedOracleParams { get; set; }
    }

    public partial class SimulateExecuteWithdrawalFunction : SimulateExecuteWithdrawalFunctionBase
    {
    }

    [Function("simulateExecuteWithdrawal")]
    public class SimulateExecuteWithdrawalFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "key", 1)] public virtual byte[] Key { get; set; }

        [Parameter("tuple", "simulatedOracleParams", 2)]
        public virtual SimulatePricesParams SimulatedOracleParams { get; set; }

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

    public partial class UpdateOrderFunction : UpdateOrderFunctionBase
    {
    }

    [Function("updateOrder")]
    public class UpdateOrderFunctionBase : FunctionMessage
    {
        [Parameter("bytes32", "key", 1)] public virtual byte[] Key { get; set; }

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

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

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

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

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

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

    public partial class WithdrawalHandlerFunction : WithdrawalHandlerFunctionBase
    {
    }

    [Function("withdrawalHandler", "address")]
    public class WithdrawalHandlerFunctionBase : FunctionMessage
    {
    }

    public partial class CollateralAlreadyClaimedError : CollateralAlreadyClaimedErrorBase
    {
    }

    [Error("CollateralAlreadyClaimed")]
    public class CollateralAlreadyClaimedErrorBase : IErrorDTO
    {
        [Parameter("uint256", "adjustedClaimableAmount", 1)]
        public virtual BigInteger AdjustedClaimableAmount { get; set; }

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

    public partial class DisabledFeatureError : DisabledFeatureErrorBase
    {
    }

    [Error("DisabledFeature")]
    public class DisabledFeatureErrorBase : IErrorDTO
    {
        [Parameter("bytes32", "key", 1)] public virtual byte[] Key { get; set; }
    }

    public partial class DisabledMarketError : DisabledMarketErrorBase
    {
    }

    [Error("DisabledMarket")]
    public class DisabledMarketErrorBase : IErrorDTO
    {
        [Parameter("address", "market", 1)] public virtual string Market { get; set; }
    }

    public partial class
        EmptyAddressInMarketTokenBalanceValidationError : EmptyAddressInMarketTokenBalanceValidationErrorBase
    {
    }

    [Error("EmptyAddressInMarketTokenBalanceValidation")]
    public class EmptyAddressInMarketTokenBalanceValidationErrorBase : IErrorDTO
    {
        [Parameter("address", "market", 1)] public virtual string Market { get; set; }
        [Parameter("address", "token", 2)] public virtual string Token { get; set; }
    }

    public partial class EmptyDepositError : EmptyDepositErrorBase
    {
    }

    [Error("EmptyDeposit")]
    public class EmptyDepositErrorBase : IErrorDTO
    {
    }

    public partial class EmptyHoldingAddressError : EmptyHoldingAddressErrorBase
    {
    }

    [Error("EmptyHoldingAddress")]
    public class EmptyHoldingAddressErrorBase : IErrorDTO
    {
    }

    public partial class EmptyMarketError : EmptyMarketErrorBase
    {
    }

    [Error("EmptyMarket")]
    public class EmptyMarketErrorBase : IErrorDTO
    {
    }

    public partial class EmptyOrderError : EmptyOrderErrorBase
    {
    }

    [Error("EmptyOrder")]
    public class EmptyOrderErrorBase : IErrorDTO
    {
    }

    public partial class EmptyReceiverError : EmptyReceiverErrorBase
    {
    }

    [Error("EmptyReceiver")]
    public class EmptyReceiverErrorBase : IErrorDTO
    {
    }

    public partial class EmptyTokenTranferGasLimitError : EmptyTokenTranferGasLimitErrorBase
    {
    }

    [Error("EmptyTokenTranferGasLimit")]
    public class EmptyTokenTranferGasLimitErrorBase : IErrorDTO
    {
        [Parameter("address", "token", 1)] public virtual string Token { get; set; }
    }

    public partial class InvalidClaimAffiliateRewardsInputError : InvalidClaimAffiliateRewardsInputErrorBase
    {
    }

    [Error("InvalidClaimAffiliateRewardsInput")]
    public class InvalidClaimAffiliateRewardsInputErrorBase : IErrorDTO
    {
        [Parameter("uint256", "marketsLength", 1)]
        public virtual BigInteger MarketsLength { get; set; }

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

    public partial class InvalidClaimCollateralInputError : InvalidClaimCollateralInputErrorBase
    {
    }

    [Error("InvalidClaimCollateralInput")]
    public class InvalidClaimCollateralInputErrorBase : IErrorDTO
    {
        [Parameter("uint256", "marketsLength", 1)]
        public virtual BigInteger MarketsLength { get; set; }

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

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

    public partial class InvalidClaimFundingFeesInputError : InvalidClaimFundingFeesInputErrorBase
    {
    }

    [Error("InvalidClaimFundingFeesInput")]
    public class InvalidClaimFundingFeesInputErrorBase : IErrorDTO
    {
        [Parameter("uint256", "marketsLength", 1)]
        public virtual BigInteger MarketsLength { get; set; }

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

    public partial class InvalidClaimUiFeesInputError : InvalidClaimUiFeesInputErrorBase
    {
    }

    [Error("InvalidClaimUiFeesInput")]
    public class InvalidClaimUiFeesInputErrorBase : IErrorDTO
    {
        [Parameter("uint256", "marketsLength", 1)]
        public virtual BigInteger MarketsLength { get; set; }

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

    public partial class InvalidClaimableFactorError : InvalidClaimableFactorErrorBase
    {
    }

    [Error("InvalidClaimableFactor")]
    public class InvalidClaimableFactorErrorBase : IErrorDTO
    {
        [Parameter("uint256", "value", 1)] public virtual BigInteger Value { get; set; }
    }

    public partial class InvalidMarketTokenBalanceError : InvalidMarketTokenBalanceErrorBase
    {
    }

    [Error("InvalidMarketTokenBalance")]
    public class InvalidMarketTokenBalanceErrorBase : IErrorDTO
    {
        [Parameter("address", "market", 1)] public virtual string Market { get; set; }
        [Parameter("address", "token", 2)] public virtual string Token { get; set; }
        [Parameter("uint256", "balance", 3)] public virtual BigInteger Balance { get; set; }

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

    public partial class
        InvalidMarketTokenBalanceForClaimableFundingError : InvalidMarketTokenBalanceForClaimableFundingErrorBase
    {
    }

    [Error("InvalidMarketTokenBalanceForClaimableFunding")]
    public class InvalidMarketTokenBalanceForClaimableFundingErrorBase : IErrorDTO
    {
        [Parameter("address", "market", 1)] public virtual string Market { get; set; }
        [Parameter("address", "token", 2)] public virtual string Token { get; set; }
        [Parameter("uint256", "balance", 3)] public virtual BigInteger Balance { get; set; }

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

    public partial class
        InvalidMarketTokenBalanceForCollateralAmountError : InvalidMarketTokenBalanceForCollateralAmountErrorBase
    {
    }

    [Error("InvalidMarketTokenBalanceForCollateralAmount")]
    public class InvalidMarketTokenBalanceForCollateralAmountErrorBase : IErrorDTO
    {
        [Parameter("address", "market", 1)] public virtual string Market { get; set; }
        [Parameter("address", "token", 2)] public virtual string Token { get; set; }
        [Parameter("uint256", "balance", 3)] public virtual BigInteger Balance { get; set; }

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

    public partial class InvalidUiFeeFactorError : InvalidUiFeeFactorErrorBase
    {
    }

    [Error("InvalidUiFeeFactor")]
    public class InvalidUiFeeFactorErrorBase : IErrorDTO
    {
        [Parameter("uint256", "uiFeeFactor", 1)]
        public virtual BigInteger UiFeeFactor { get; set; }

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

    public partial class TokenTransferErrorError : TokenTransferErrorErrorBase
    {
    }

    [Error("TokenTransferError")]
    public class TokenTransferErrorErrorBase : IErrorDTO
    {
        [Parameter("address", "token", 1)] public virtual string Token { get; set; }
        [Parameter("address", "receiver", 2)] public virtual string Receiver { get; set; }
        [Parameter("uint256", "amount", 3)] public virtual BigInteger Amount { get; set; }
    }

    public partial class UnauthorizedError : UnauthorizedErrorBase
    {
    }

    [Error("Unauthorized")]
    public class UnauthorizedErrorBase : IErrorDTO
    {
        [Parameter("address", "msgSender", 1)] public virtual string MsgSender { get; set; }
        [Parameter("string", "role", 2)] public virtual string Role { get; set; }
    }


    public partial class DataStoreOutputDTO : DataStoreOutputDTOBase
    {
    }

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

    public partial class DepositHandlerOutputDTO : DepositHandlerOutputDTOBase
    {
    }

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

    public partial class EventEmitterOutputDTO : EventEmitterOutputDTOBase
    {
    }

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


    public partial class ExternalHandlerOutputDTO : ExternalHandlerOutputDTOBase
    {
    }

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


    public partial class OrderHandlerOutputDTO : OrderHandlerOutputDTOBase
    {
    }

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

    public partial class RoleStoreOutputDTO : RoleStoreOutputDTOBase
    {
    }

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

    public partial class RouterOutputDTO : RouterOutputDTOBase
    {
    }

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


    public partial class ShiftHandlerOutputDTO : ShiftHandlerOutputDTOBase
    {
    }

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


    public partial class WithdrawalHandlerOutputDTO : WithdrawalHandlerOutputDTOBase
    {
    }

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