Enumerations.h

Go to the documentation of this file.

/*
 * Copyright Onix Solutions Limited [OnixS]. All rights reserved.
 *
 * This software owned by Onix Solutions Limited [OnixS] and is protected by copyright law
 * and international copyright treaties.
 *
 * Access to and use of the software is governed by the terms of the applicable ONIXS Software
 * Services Agreement (the Agreement) and Customer end user license agreements granting
 * a non-assignable, non-transferable and non-exclusive license to use the software
 * for it's own data processing purposes under the terms defined in the Agreement.
 *
 * Except as otherwise granted within the terms of the Agreement, copying or reproduction of any
 * part of this source code or associated reference material to any other location for further
 * reproduction or redistribution, and any amendments to this copyright notice, are expressly
 * prohibited.
 *
 * Any reproduction or redistribution for sale or hiring of the Software not in accordance with
 * the terms of the Agreement is a violation of copyright law.
 */

#pragma once

#include "OnixS/Eurex/Trading/Export.h"

#include <string>

namespace OnixS { namespace Eurex { namespace Trading {

/// Identifier for subscription and retransmission of an ETI data stream.
struct ONIXS_EUREX_ETI_EXPORT ApplId
{
    /// \copydoc ApplId
    enum Enum
    {
        NoValue = 0xFF,                 ///< No value.
        Trade = 1,                      ///< Trade.
        News = 2,                       ///< News.
        ServiceAvailability = 3,        ///< Service Availability.
        SessionData = 4,                ///< Session Data.
        ListenerData = 5,               ///< Listener Data.
        RiskControl = 6,                ///< Risk Control.
        TESMaintenance = 7,             ///< TES Maintenance.
        TESTrade = 8,                   ///< TES Trade.
        SRQSMaintenance = 9,            ///< SRQS Maintenance.
        ServiceAvailabilityMarket = 10, ///< Service Availability Market.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(ApplId::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, ApplId::Enum);

/// Subscription status.
struct ONIXS_EUREX_ETI_EXPORT ApplIdStatus
{
    /// \copydoc ApplIdStatus
    enum Enum
    {
        NoValue = 0xFF,                ///< No value.
        OutboundConversionError = 105, ///< Error converting response or broadcast.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(ApplIdStatus::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, ApplIdStatus::Enum);

/// Indicates a retransmission message.
struct ONIXS_EUREX_ETI_EXPORT ApplResendFlag
{
    /// \copydoc ApplResendFlag
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        False = 0,      ///< False.
        True = 1,       ///< True.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(ApplResendFlag::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, ApplResendFlag::Enum);

/// Indicates if the order is a Lean Order or a Standard (non lean) Order.
struct ONIXS_EUREX_ETI_EXPORT ApplSeqIndicator
{
    /// \copydoc ApplSeqIndicator
    enum Enum
    {
        NoValue = 0xFF,         ///< No value.
        NoRecoveryRequired = 0, ///< No Recovery Required.
        RecoveryRequired = 1,   ///< Recovery Required.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(ApplSeqIndicator::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, ApplSeqIndicator::Enum);

/// Informs about the availability of the retransmission services for order and quote events (session data and listener
/// data).
struct ONIXS_EUREX_ETI_EXPORT ApplSeqStatus
{
    /// \copydoc ApplSeqStatus
    enum Enum
    {
        NoValue = 0xFF,  ///< No value.
        Unavailable = 0, ///< Unavailable.
        Available = 1,   ///< Available.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(ApplSeqStatus::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, ApplSeqStatus::Enum);

/// Type of order processing.
struct ONIXS_EUREX_ETI_EXPORT ApplUsageOrders
{
    /// \copydoc ApplUsageOrders
    enum Enum
    {
        NoValue = 0x00,   ///< No value.
        Automated = 'A',  ///< Automated.
        Manual = 'M',     ///< Manual.
        AutoSelect = 'B', ///< Both (Automated and Manual).
        None = 'N',       ///< None.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(ApplUsageOrders::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, ApplUsageOrders::Enum);

/// Type of quote processing.
struct ONIXS_EUREX_ETI_EXPORT ApplUsageQuotes
{
    /// \copydoc ApplUsageQuotes
    enum Enum
    {
        NoValue = 0x00,   ///< No value.
        Automated = 'A',  ///< Automated.
        Manual = 'M',     ///< Manual.
        AutoSelect = 'B', ///< Both (Automated and Manual).
        None = 'N',       ///< None.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(ApplUsageQuotes::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, ApplUsageQuotes::Enum);

/// Used to indicate anonymized trades in baskets.
struct ONIXS_EUREX_ETI_EXPORT BasketAnonymity
{
    /// \copydoc BasketAnonymity
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        No = 0,         ///< No.
        Yes = 1,        ///< Yes.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(BasketAnonymity::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, BasketAnonymity::Enum);

/// Basket operation.
struct ONIXS_EUREX_ETI_EXPORT BasketTradeReportType
{
    /// \copydoc BasketTradeReportType
    enum Enum
    {
        NoValue = 0xFF,     ///< No value.
        Submit = 0,         ///< Submit.
        Addendum = 4,       ///< Addendum.
        NoWasSubstitue = 5, ///< No/Was (Substitute).
        Terminate = 19,     ///< Terminate.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(BasketTradeReportType::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, BasketTradeReportType::Enum);

/// BidPx is locked.
struct ONIXS_EUREX_ETI_EXPORT BidPxIsLocked
{
    /// \copydoc BidPxIsLocked
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        No = 0,         ///< No.
        Yes = 1,        ///< Yes.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(BidPxIsLocked::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, BidPxIsLocked::Enum);

/// Instruction to show Charge ID.
struct ONIXS_EUREX_ETI_EXPORT ChargeIdDisclosureInstruction
{
    /// \copydoc ChargeIdDisclosureInstruction
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        No = 0,         ///< No.
        Yes = 1,        ///< Yes.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(ChargeIdDisclosureInstruction::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, ChargeIdDisclosureInstruction::Enum);

/// Prioritization of a cross order.
struct ONIXS_EUREX_ETI_EXPORT CrossPrioritization
{
    /// \copydoc CrossPrioritization
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        BuySide = 1,    ///< Buy side is prioritized.
        SellSide = 2,   ///< Sell side is prioritized.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(CrossPrioritization::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, CrossPrioritization::Enum);

/// Type of the Cross Request.
struct ONIXS_EUREX_ETI_EXPORT CrossRequestType
{
    /// \copydoc CrossRequestType
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        Cross = 1,      ///< Cross Announcement.
        Clip = 2,       ///< Liquidity Improvement Cross.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(CrossRequestType::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, CrossRequestType::Enum);

/// Type of cross being submitted to a market.
struct ONIXS_EUREX_ETI_EXPORT CrossType
{
    /// \copydoc CrossType
    enum Enum
    {
        NoValue = 0xFF,   ///< No value.
        CrossIOC = 2,     ///< Immediate-or-cancel-cross.
        CrossOneSide = 3, ///< One sided cross - unfilled quantity remains active after crossing. Only applicable for
                          ///< CrossRequestType(28771) = 1(Cross Announcement).
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(CrossType::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, CrossType::Enum);

/// Indicates SMP involvement.
struct ONIXS_EUREX_ETI_EXPORT CrossedIndicator
{
    /// \copydoc CrossedIndicator
    enum Enum
    {
        NoValue = 0xFF,    ///< No value.
        NoCrossing = 0,    ///< No crossing (Order not subject to crossing).
        CrossRejected = 1, ///< Cross rejected (Order subject to crossing and match prevented).
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(CrossedIndicator::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, CrossedIndicator::Enum);

/// Identifies the source of an order, in accordance with the FIA guidelines for a rate Identifier. The field is for
/// participant use only. Valid characters: 0x20, 0x22-0x7B, 0x7D, 0x7E.
struct ONIXS_EUREX_ETI_EXPORT CustOrderHandlingInst
{
    /// \copydoc CustOrderHandlingInst
    enum Enum
    {
        NoValue = 0x00, ///< No value.
        W = 'W',        ///< Desk.
        Y = 'Y',        ///< Electronic.
        C = 'C',        ///< Vendor-provided Platform billed by Executing Broker.
        G = 'G',        ///< Sponsored Access via Exchange API or FIX provided by Executing Broker.
        H = 'H',        ///< Premium Algorithmic Trading Provider billed by Executing Broker.
        D = 'D',        ///< Other, including Other-provided Screen.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(CustOrderHandlingInst::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, CustOrderHandlingInst::Enum);

/// Reason for deletion.
struct ONIXS_EUREX_ETI_EXPORT DeleteReason
{
    /// \copydoc DeleteReason
    enum Enum
    {
        NoValue = 0xFF,               ///< No value.
        NoSpecialReason = 100,        ///< Deletion via the TES Delete Request.
        TASChange = 101,              ///< Automatic deletion due to TES Activity State Change.
        IntradayExpiration = 102,     ///< Automatic deletion due to instrument expiration.
        RiskEvent = 103,              ///< Deletion caused by Clearing/Risk stop.
        StopTrading = 104,            ///< Deletion caused by Trading stop.
        InstrumentDeletion = 105,     ///< Deletion of Instrument.
        InstrumentSuspension = 106,   ///< Suspension of Instrument.
        PreTradeRiskEvent = 107,      ///< Deletion caused by a pre-trade risk event.
        AmendmentReset = 108,         ///< Basket amendment cancelled.
        AmendmentUserCancelled = 109, ///< Amendment cancelled by user action.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(DeleteReason::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, DeleteReason::Enum);

/// Transaction effect on a basket.
struct ONIXS_EUREX_ETI_EXPORT EffectOnBasket
{
    /// \copydoc EffectOnBasket
    enum Enum
    {
        NoValue = 0xFF,   ///< No value.
        AddVolume = 1,    ///< Add volume.
        RemoveVolume = 2, ///< Remove volume.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(EffectOnBasket::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, EffectOnBasket::Enum);

/// Enlight RFQ Average Response Rate Ranking.
struct ONIXS_EUREX_ETI_EXPORT EnlightRFQAvgRespRateRanking
{
    /// \copydoc EnlightRFQAvgRespRateRanking
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        Low = 1,        ///< Low.
        Medium = 2,     ///< Medium.
        High = 3,       ///< High.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(EnlightRFQAvgRespRateRanking::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, EnlightRFQAvgRespRateRanking::Enum);

/// Enlight RFQ Average Response Time Ranking.
struct ONIXS_EUREX_ETI_EXPORT EnlightRFQAvgRespTimeRanking
{
    /// \copydoc EnlightRFQAvgRespTimeRanking
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        Low = 1,        ///< Low.
        Medium = 2,     ///< Medium.
        High = 3,       ///< High.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(EnlightRFQAvgRespTimeRanking::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, EnlightRFQAvgRespTimeRanking::Enum);

/// Eurex Volume Ranking.
struct ONIXS_EUREX_ETI_EXPORT EurexVolumeRanking
{
    /// \copydoc EurexVolumeRanking
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        Low = 1,        ///< Low.
        Medium = 2,     ///< Medium.
        High = 3,       ///< High.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(EurexVolumeRanking::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, EurexVolumeRanking::Enum);

/// Code to represent the type of event.
struct ONIXS_EUREX_ETI_EXPORT EventType
{
    /// \copydoc EventType
    enum Enum
    {
        NoValue = 0xFF,    ///< No value.
        SwapStartDate = 8, ///< Swap Start Date.
        SwapEndDate = 9,   ///< Swap End Date.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(EventType::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, EventType::Enum);

/// Instructions for order handling, represented as a bit map.
struct ONIXS_EUREX_ETI_EXPORT ExecInst
{
    /// \copydoc ExecInst
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        H = 1,          ///< Persistent Order (FIX value 'H').
        Q = 2,          ///< Non-persistent Order (FIX value 'Q').
        HQ = 3,         ///< Persistent and non-persistent orders affected (FIX value 'H Q').
        H6 = 5,         ///< Persistent and Book or Cancel order (FIX value 'H 6').
        Q6 = 6,         ///< Non-persistent and Book or Cancel order (FIX value 'Q 6').
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(ExecInst::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, ExecInst::Enum);

/// Code to further qualify the field ExecType (150) of the Execution Report (8) message.
struct ONIXS_EUREX_ETI_EXPORT ExecRestatementReason
{
    /// \copydoc ExecRestatementReason
    enum Enum
    {
        NoValue = 0xFF,                    ///< No value.
        OrderBookRestatement = 1,          ///< Order book restatement.
        OrderAdded = 101,                  ///< Order add accepted.
        OrderModified = 102,               ///< Order modify accepted.
        OrderCancelled = 103,              ///< Order delete accepted.
        IOCOrderCancelled = 105,           ///< IOC Order accepted.
        FOKOrderCancelled = 107,           ///< FOK Order accepted.
        BookOrderExecuted = 108,           ///< Book Order executed.
        ChangedToIOC = 114,                ///< Order has been changed to IOC.
        MemberDisable = 117,               ///< Member has been disabled.
        InstrumentStateChange = 122,       ///< Instrument State Change.
        MarketOrderTriggered = 135,        ///< Market Order triggered and executed.
        CAOOrderActivated = 149,           ///< Closing Auction Order has been activated.
        CAOOrderInactivated = 150,         ///< Closing Auction Order has been inactivated.
        OAOOrderActivated = 151,           ///< Opening Auction Order has been activated.
        OAOOrderInactivated = 152,         ///< Opening Auction Order has been inactivated.
        AAOOrderActivated = 153,           ///< Any Auction Order has been activated.
        AAOOrderInactivated = 154,         ///< Any Auction Order has been inactivated.
        OCOOrderTriggered = 164,           ///< One-cancels-the-other Order has been triggered.
        StopOrderTriggered = 172,          ///< Stop Order has been triggered.
        OwnershipChanged = 181,            ///< Ownership Changed.
        OrderCancellationPending = 197,    ///< Pending order deletion.
        PendingCancellationExecuted = 199, ///< Pending order cancellation processed (end of FREEZE state).
        BOCOrderCancelled = 212,           ///< Book or Cancel Order accepted.
        PanicCancel = 261,                 ///< Panic Cancel.
        MarketOrderUncrossing = 302,       ///< Market Order uncrossing.
        CLIPExecution = 340,               ///< CLIP execution after improvement period.
        CLIPArrangementTimeOut = 343,      ///< CLIP Request deleted by arrangement time out.
        CLIPArrangementValidation = 344,   ///< CLIP Request deleted by arrangement validation.
        CrossOrderAdded = 346,             ///< Cross order added.
        CrossOrderCancelled = 347,         ///< Cross order cancelled.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(ExecRestatementReason::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, ExecRestatementReason::Enum);

/// The reason why this message was generated.
struct ONIXS_EUREX_ETI_EXPORT ExecType
{
    /// \copydoc ExecType
    enum Enum
    {
        NoValue = 0x00,       ///< No value.
        New = '0',            ///< New.
        Canceled = '4',       ///< Cancelled.
        Replaced = '5',       ///< Replaced.
        PendingCancelE = '6', ///< Pending Cancel (e.g. result of Order Cancel Request).
        Suspended = '9',      ///< Suspended.
        Restated = 'D',       ///< Restated.
        Triggered = 'L',      ///< Triggered.
        Trade = 'F',          ///< Trade.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(ExecType::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, ExecType::Enum);

/// Qualifier for field ExecutingTrader. It is required to distinguish between natural persons and Algos.
struct ONIXS_EUREX_ETI_EXPORT ExecutingTraderQualifier
{
    /// \copydoc ExecutingTraderQualifier
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        Algo = 22,      ///< Algo.
        Human = 24,     ///< Human/Natural person.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(ExecutingTraderQualifier::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, ExecutingTraderQualifier::Enum);

/// Type of exercise of an instrument.
struct ONIXS_EUREX_ETI_EXPORT ExerciseStyle
{
    /// \copydoc ExerciseStyle
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        European = 0,   ///< European.
        American = 1,   ///< American.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(ExerciseStyle::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, ExerciseStyle::Enum);

/// Indicates whether the order added or removed liquidity.
struct ONIXS_EUREX_ETI_EXPORT FillLiquidityInd
{
    /// \copydoc FillLiquidityInd
    enum Enum
    {
        NoValue = 0xFF,           ///< No value.
        AddedLiquidity = 1,       ///< Added Liquidity.
        RemovedLiquidity = 2,     ///< Removed Liquidity.
        Auction = 4,              ///< Auction.
        TriggeredStopOrder = 5,   ///< Triggered Stop Order.
        TriggeredOCOOrder = 6,    ///< Triggered OCO Order.
        TriggeredMarketOrder = 7, ///< Triggered Market Order.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(FillLiquidityInd::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, FillLiquidityInd::Enum);

/// Instruction to show FreeText5.
struct ONIXS_EUREX_ETI_EXPORT FreeText5DisclosureInstruction
{
    /// \copydoc FreeText5DisclosureInstruction
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        No = 0,         ///< No.
        Yes = 1,        ///< Yes.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(FreeText5DisclosureInstruction::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, FreeText5DisclosureInstruction::Enum);

/// Status of ETI Gateway.
struct ONIXS_EUREX_ETI_EXPORT GatewayStatus
{
    /// \copydoc GatewayStatus
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        Standby = 0,    ///< Standby.
        Active = 1,     ///< Active.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(GatewayStatus::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, GatewayStatus::Enum);

/// Hedging method.
struct ONIXS_EUREX_ETI_EXPORT HedgeType
{
    /// \copydoc HedgeType
    enum Enum
    {
        NoValue = 0xFF,       ///< No value.
        DurationHedge = 0,    ///< Duration Hedge.
        NominalHedge = 1,     ///< Nominal Hedge.
        PriceFactorHedge = 2, ///< Price Factor Hedge.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(HedgeType::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, HedgeType::Enum);

/// Indication for the hedge transaction.
struct ONIXS_EUREX_ETI_EXPORT HedgingInstruction
{
    /// \copydoc HedgingInstruction
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        OnClose = 1,    ///< Execute hedge transaction in the closing auction of the underlying.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(HedgingInstruction::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, HedgingInstruction::Enum);

/// Indicates whether a option strategy synthetic BBO is used for the price improvement check.
struct ONIXS_EUREX_ETI_EXPORT ImpliedCheckPriceIndicator
{
    /// \copydoc ImpliedCheckPriceIndicator
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        No = 0,         ///< No.
        Yes = 1,        ///< Yes.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(ImpliedCheckPriceIndicator::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, ImpliedCheckPriceIndicator::Enum);

/// Indicates that an implied market to be created for either the legs of a multi-leg instrument (Implied-in) or for the
/// multi-leg instrument based on the existence of the legs (Implied-out).
struct ONIXS_EUREX_ETI_EXPORT ImpliedMarketIndicator
{
    /// \copydoc ImpliedMarketIndicator
    enum Enum
    {
        NoValue = 0xFF,   ///< No value.
        NotImplied = 0,   ///< Not implied.
        ImpliedInOut = 3, ///< Both Implied-in and Implied-out.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(ImpliedMarketIndicator::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, ImpliedMarketIndicator::Enum);

/// Role on/for a message.
struct ONIXS_EUREX_ETI_EXPORT InputSource
{
    /// \copydoc InputSource
    enum Enum
    {
        NoValue = 0xFF,        ///< No value.
        ClientBroker = 1,      ///< Client Broker.
        ProprietaryBroker = 2, ///< Proprietary Broker.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(InputSource::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, InputSource::Enum);

/// Code to represent the type of instrument attribute.
struct ONIXS_EUREX_ETI_EXPORT InstrAttribType
{
    /// \copydoc InstrAttribType
    enum Enum
    {
        NoValue = 0xFF,                      ///< No value.
        VariableRate = 5,                    ///< Variable rate.
        CouponRate = 100,                    ///< Coupon rate.
        OffsetToTheVariableCouponRate = 101, ///< Offset to the variable coupon rate.
        SwapCustomer1 = 102,                 ///< Swap Customer 1.
        SwapCustomer2 = 103,                 ///< Swap Customer 2.
        CashBasketReference = 104,           ///< Cash Basket Reference.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(InstrAttribType::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, InstrAttribType::Enum);

/// Indicator for checking open orders and quotes.
struct ONIXS_EUREX_ETI_EXPORT InventoryCheckType
{
    /// \copydoc InventoryCheckType
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        DoNotCheck = 0, ///< Do not check.
        Check = 1,      ///< Check.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(InventoryCheckType::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, InventoryCheckType::Enum);

/// Indicates whether this message is the last fragment (part) of a sequence of messages belonging to one dedicated
/// transaction.
struct ONIXS_EUREX_ETI_EXPORT LastFragment
{
    /// \copydoc LastFragment
    enum Enum
    {
        NoValue = 0xFF,     ///< No value.
        NotLastMessage = 0, ///< Not Last Message.
        LastMessage = 1,    ///< Last Message.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(LastFragment::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, LastFragment::Enum);

/// Last market.
struct ONIXS_EUREX_ETI_EXPORT LastMkt
{
    /// \copydoc LastMkt
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        XEUR = 1,       ///< XEUR.
        XEEE = 2,       ///< XEEE.
        NODX = 12,      ///< NODX.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(LastMkt::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, LastMkt::Enum);

/// Instruction to show last deal price.
struct ONIXS_EUREX_ETI_EXPORT LastPxDisclosureInstruction
{
    /// \copydoc LastPxDisclosureInstruction
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        No = 0,         ///< No.
        Yes = 1,        ///< Yes.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(LastPxDisclosureInstruction::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, LastPxDisclosureInstruction::Enum);

/// Instruction to show last deal quantity. Can only be set to 1 (Yes) if LastQtyDisclosureInstruction = 1 (Yes).
struct ONIXS_EUREX_ETI_EXPORT LastQtyDisclosureInstruction
{
    /// \copydoc LastQtyDisclosureInstruction
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        No = 0,         ///< No.
        Yes = 1,        ///< Yes.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(LastQtyDisclosureInstruction::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, LastQtyDisclosureInstruction::Enum);

/// Leaves quantity disclosure instruction.
struct ONIXS_EUREX_ETI_EXPORT LeavesQtyDisclosureInstruction
{
    /// \copydoc LeavesQtyDisclosureInstruction
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        No = 0,         ///< No.
        Yes = 1,        ///< Yes.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(LeavesQtyDisclosureInstruction::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, LeavesQtyDisclosureInstruction::Enum);

/// Role on/for a message.
struct ONIXS_EUREX_ETI_EXPORT LegInputSource
{
    /// \copydoc LegInputSource
    enum Enum
    {
        NoValue = 0xFF,        ///< No value.
        ClientBroker = 1,      ///< Client Broker.
        ProprietaryBroker = 2, ///< Proprietary Broker.
        BuySide = 3,           ///< Buy side.
        SellSide = 4,          ///< Sell side.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(LegInputSource::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, LegInputSource::Enum);

/// Leg-specific field used for Eurex position management purposes and indicates whether the leg is submitted to open or
/// close a position.
struct ONIXS_EUREX_ETI_EXPORT LegPositionEffect
{
    /// \copydoc LegPositionEffect
    enum Enum
    {
        NoValue = 0x00, ///< No value.
        Close = 'C',    ///< Close.
        Open = 'O',     ///< Open.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(LegPositionEffect::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, LegPositionEffect::Enum);

/// Indicates type of leg.
struct ONIXS_EUREX_ETI_EXPORT LegSecurityType
{
    /// \copydoc LegSecurityType
    enum Enum
    {
        NoValue = 0xFF,         ///< No value.
        MultilegInstrument = 1, ///< Multileg Instrument.
        UnderlyingLeg = 2,      ///< Underlying Leg.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(LegSecurityType::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, LegSecurityType::Enum);

/// The side of the individual leg of a strategy.
struct ONIXS_EUREX_ETI_EXPORT LegSide
{
    /// \copydoc LegSide
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        Buy = 1,        ///< Buy.
        Sell = 2,       ///< Sell.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(LegSide::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, LegSide::Enum);

/// List update action.
struct ONIXS_EUREX_ETI_EXPORT ListUpdateAction
{
    /// \copydoc ListUpdateAction
    enum Enum
    {
        NoValue = 0x00, ///< No value.
        Add = 'A',      ///< Add (Invocation).
        Delete = 'D',   ///< Delete (Release).
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(ListUpdateAction::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, ListUpdateAction::Enum);

/// Type of market data.
struct ONIXS_EUREX_ETI_EXPORT MDBookType
{
    /// \copydoc MDBookType
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        TopOfBook = 1,  ///< Top of book.
        PriceDepth = 2, ///< Price depth (aggregated).
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(MDBookType::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, MDBookType::Enum);

/// Sub-type (qualifier) of market data.
struct ONIXS_EUREX_ETI_EXPORT MDSubBookType
{
    /// \copydoc MDSubBookType
    enum Enum
    {
        NoValue = 0xFF,            ///< No value.
        Implied = 1,               ///< Implied.
        VolumeWeightedAverage = 2, ///< Volume Weighted Average.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(MDSubBookType::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, MDSubBookType::Enum);

/// Action for reaching risk limit.
struct ONIXS_EUREX_ETI_EXPORT MMRiskLimitActionType
{
    /// \copydoc MMRiskLimitActionType
    enum Enum
    {
        NoValue = 0xFF,               ///< No value.
        QuoteInactivate = 1,          ///< Quote inactivate.
        QuoteInactivateAndDelete = 2, ///< Quote inactivate and delete.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(MMRiskLimitActionType::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, MMRiskLimitActionType::Enum);

/// Market ID.
struct ONIXS_EUREX_ETI_EXPORT MarketId
{
    /// \copydoc MarketId
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        XEUR = 1,       ///< XEUR.
        XEEE = 2,       ///< XEEE.
        NODX = 12,      ///< NODX.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(MarketId::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, MarketId::Enum);

/// Reason for mass cancellation.
struct ONIXS_EUREX_ETI_EXPORT MassActionReason
{
    /// \copydoc MassActionReason
    enum Enum
    {
        NoValue = 0xFF,                       ///< No value.
        NoSpecialReason = 0,                  ///< No special reason.
        StopTrading = 1,                      ///< Trading was stopped.
        Emergency = 2,                        ///< Emergency.
        MarketMakerProtection = 3,            ///< Market Maker Protection.
        SessionLoss = 6,                      ///< Session loss or logout.
        DuplicateSessionLogin = 7,            ///< Duplicate Session Login.
        ClearingRiskControl = 8,              ///< Clearing Risk Control.
        InternalConnectionLoss = 100,         ///< Internal connection loss.
        ProductStateHalt = 105,               ///< Product State Halt.
        ProductStateHoliday = 106,            ///< Product State Holiday.
        InstrumentSuspended = 107,            ///< Instrument Suspended.
        ComplexInstrumentDeletion = 109,      ///< Complex Instrument Deletion.
        VolatilityInterruption = 110,         ///< Volatility Interruption.
        ProductTemporarilyNotTradeable = 111, ///< Product temporarily not tradeable.
        MemberDisable = 117,                  ///< Member has been disabled.
        ScaledSimpleInstrumentDeletion = 121, ///< Scaled Simple Instrument Deletion.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(MassActionReason::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, MassActionReason::Enum);

/// Restriction for MassActionType (1373) = Release_quotes (2).
struct ONIXS_EUREX_ETI_EXPORT MassActionSubType
{
    /// \copydoc MassActionSubType
    enum Enum
    {
        NoValue = 0xFF,   ///< No value.
        BookOrCancel = 1, ///< Book or cancel.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(MassActionSubType::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, MassActionSubType::Enum);

/// Specifies the type of action requested.
struct ONIXS_EUREX_ETI_EXPORT MassActionType
{
    /// \copydoc MassActionType
    enum Enum
    {
        NoValue = 0xFF,          ///< No value.
        SuspendQuotes = 1,       ///< Suspend quotes.
        ReleaseQuotes = 2,       ///< Release quotes from suspension.
        SuspendDeleteQuotes = 3, ///< Suspend and delete Quotes.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(MassActionType::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, MassActionType::Enum);

/// Indicates the auction type the trade originates from.
struct ONIXS_EUREX_ETI_EXPORT MatchSubType
{
    /// \copydoc MatchSubType
    enum Enum
    {
        NoValue = 0xFF,            ///< No value.
        OpeningAuction = 1,        ///< Opening auction.
        ClosingAuction = 2,        ///< Closing auction.
        IntradayAuction = 3,       ///< Intraday auction.
        CircuitBreakerAuction = 4, ///< Circuit Breaker auction.
        OutsideBBO = 6,            ///< CLIP matching outside BBO.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(MatchSubType::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, MatchSubType::Enum);

/// The point in the matching process at which this trade was matched.
struct ONIXS_EUREX_ETI_EXPORT MatchType
{
    /// \copydoc MatchType
    enum Enum
    {
        NoValue = 0xFF,                 ///< No value.
        ConfirmedTradeReport = 3,       ///< Confirmed Trade Report (reporting from recognized markets).
        AutoMatchIncoming = 4,          ///< Auto-match incoming order.
        CrossAuction = 5,               ///< Cross Auction.
        CallAuction = 7,                ///< Call Auction.
        AutoMatchResting = 11,          ///< Auto match resting order.
        LiquidityImprovementCross = 13, ///< Liquidity Improvement Cross.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(MatchType::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, MatchType::Enum);

/// Informs if trading is active for grouping of Eurex products.
struct ONIXS_EUREX_ETI_EXPORT MatchingEngineStatus
{
    /// \copydoc MatchingEngineStatus
    enum Enum
    {
        NoValue = 0xFF,  ///< No value.
        Unavailable = 0, ///< Unavailable.
        Available = 1,   ///< Available.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(MatchingEngineStatus::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, MatchingEngineStatus::Enum);

/// Receiver of a message.
struct ONIXS_EUREX_ETI_EXPORT MessageEventSource
{
    /// \copydoc MessageEventSource
    enum Enum
    {
        NoValue = 0x00,                  ///< No value.
        BroadcastToInitiator = 'I',      ///< Broadcast to initiator.
        BroadcastToApprover = 'A',       ///< Broadcast to approver.
        BroadcastToRequester = 'R',      ///< Broadcast to requester.
        BroadcastToQuoteSubmitter = 'Q', ///< Broadcast to quote submitter.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(MessageEventSource::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, MessageEventSource::Enum);

/// Indicates if the trade resulted from a single order or a multi leg order.
struct ONIXS_EUREX_ETI_EXPORT MultiLegReportingType
{
    /// \copydoc MultiLegReportingType
    enum Enum
    {
        NoValue = 0xFF,                       ///< No value.
        SingleSecurity = 1,                   ///< Single instrument.
        IndividualLegOfAMultilegSecurity = 2, ///< Complex instrument.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(MultiLegReportingType::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, MultiLegReportingType::Enum);

/// Specifies if a strategy is temporarily (user-defined) or permanently (predefined) available.
struct ONIXS_EUREX_ETI_EXPORT MultilegModel
{
    /// \copydoc MultilegModel
    enum Enum
    {
        NoValue = 0xFF,                 ///< No value.
        PredefinedMultilegSecurity = 0, ///< Predefined Multileg Security.
        UserDefinedMultleg = 1,         ///< User-defined Multleg Security.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(MultilegModel::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, MultilegModel::Enum);

/// Price decomposition method for legs of a complex instrument.
struct ONIXS_EUREX_ETI_EXPORT MultilegPriceModel
{
    /// \copydoc MultilegPriceModel
    enum Enum
    {
        NoValue = 0xFF,  ///< No value.
        Standard = 0,    ///< leg level prices provided by system.
        UserDefined = 1, ///< leg level prices provided by user.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(MultilegPriceModel::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, MultilegPriceModel::Enum);

/// State of the News Retransmission Service.
struct ONIXS_EUREX_ETI_EXPORT NewsRtmServiceStatus
{
    /// \copydoc NewsRtmServiceStatus
    enum Enum
    {
        NoValue = 0xFF,  ///< No value.
        Unavailable = 0, ///< Unavailable.
        Available = 1,   ///< Available.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(NewsRtmServiceStatus::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, NewsRtmServiceStatus::Enum);

/// Instruction to show total number of Respondents in a SRQS event.
struct ONIXS_EUREX_ETI_EXPORT NumberOfRespDisclosureInstruction
{
    /// \copydoc NumberOfRespDisclosureInstruction
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        No = 0,         ///< No.
        Yes = 1,        ///< Yes.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(NumberOfRespDisclosureInstruction::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, NumberOfRespDisclosureInstruction::Enum);

/// OfferPx is locked.
struct ONIXS_EUREX_ETI_EXPORT OfferPxIsLocked
{
    /// \copydoc OfferPxIsLocked
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        No = 0,         ///< No.
        Yes = 1,        ///< Yes.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(OfferPxIsLocked::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, OfferPxIsLocked::Enum);

/// Indicates whether the counterparties have the right for early termination.
struct ONIXS_EUREX_ETI_EXPORT OptionalEarlyTerminationIndicator
{
    /// \copydoc OptionalEarlyTerminationIndicator
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        No = 0,         ///< No.
        Yes = 1,        ///< Yes.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(OptionalEarlyTerminationIndicator::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, OptionalEarlyTerminationIndicator::Enum);

/// Conveys the current status of an order.
struct ONIXS_EUREX_ETI_EXPORT OrdStatus
{
    /// \copydoc OrdStatus
    enum Enum
    {
        NoValue = 0x00,        ///< No value.
        New = '0',             ///< New.
        PartiallyFilled = '1', ///< Partially filled.
        Filled = '2',          ///< Filled.
        Canceled = '4',        ///< Cancelled.
        PendingCancel = '6',   ///< Pending Cancel (i.e. result of Order Cancel Request).
        Suspended = '9',       ///< Suspended.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(OrdStatus::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, OrdStatus::Enum);

/// Order type.
struct ONIXS_EUREX_ETI_EXPORT OrdType
{
    /// \copydoc OrdType
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        Market = 1,     ///< Market.
        Limit = 2,      ///< Limit.
        Stop = 3,       ///< Stop.
        StopLimit = 4,  ///< Stop Limit.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(OrdType::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, OrdType::Enum);

/// Order attribute liquidity provision.
struct ONIXS_EUREX_ETI_EXPORT OrderAttributeLiquidityProvision
{
    /// \copydoc OrderAttributeLiquidityProvision
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        Y = 1,          ///< Liquidity provision.
        N = 0,          ///< No liquidity provision.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(OrderAttributeLiquidityProvision::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, OrderAttributeLiquidityProvision::Enum);

/// Order attribute risk reduction.
struct ONIXS_EUREX_ETI_EXPORT OrderAttributeRiskReduction
{
    /// \copydoc OrderAttributeRiskReduction
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        Y = 1,          ///< Risk reduction.
        N = 0,          ///< No risk reduction.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(OrderAttributeRiskReduction::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, OrderAttributeRiskReduction::Enum);

/// Indicates if the trade notification results from an order or quote.
struct ONIXS_EUREX_ETI_EXPORT OrderCategory
{
    /// \copydoc OrderCategory
    enum Enum
    {
        NoValue = 0x00, ///< No value.
        Order = '1',    ///< Order.
        Quote = '2',    ///< Quote.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(OrderCategory::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, OrderCategory::Enum);

/// Action that caused the event to occur.
struct ONIXS_EUREX_ETI_EXPORT OrderEventReason
{
    /// \copydoc OrderEventReason
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        SMP = 100,      ///< SMP event.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(OrderEventReason::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, OrderEventReason::Enum);

/// Order origination, MiFID field - to indicate order received from a direct access or sponsored access customer.
struct ONIXS_EUREX_ETI_EXPORT OrderOrigination
{
    /// \copydoc OrderOrigination
    enum Enum
    {
        NoValue = 0xFF,                            ///< No value.
        DirectAccessOrSponsoredAccessCustomer = 5, ///< Order received from a direct access customer.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(OrderOrigination::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, OrderOrigination::Enum);

/// Instruction to show total quantity.
struct ONIXS_EUREX_ETI_EXPORT OrderQtyDisclosureInstruction
{
    /// \copydoc OrderQtyDisclosureInstruction
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        No = 0,         ///< No.
        Yes = 1,        ///< Yes.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(OrderQtyDisclosureInstruction::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, OrderQtyDisclosureInstruction::Enum);

/// OrderQty is locked.
struct ONIXS_EUREX_ETI_EXPORT OrderQtyIsLocked
{
    /// \copydoc OrderQtyIsLocked
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        No = 0,         ///< No.
        Yes = 1,        ///< Yes.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(OrderQtyIsLocked::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, OrderQtyIsLocked::Enum);

/// Indicates if the participant application is an order routing system.
struct ONIXS_EUREX_ETI_EXPORT OrderRoutingIndicator
{
    /// \copydoc OrderRoutingIndicator
    enum Enum
    {
        NoValue = 0x00, ///< No value.
        Yes = 'Y',      ///< Yes.
        No = 'N',       ///< No.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(OrderRoutingIndicator::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, OrderRoutingIndicator::Enum);

/// Side of the order in the original Eurex strategy.
struct ONIXS_EUREX_ETI_EXPORT OrderSide
{
    /// \copydoc OrderSide
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        Buy = 1,        ///< Buy.
        Sell = 2,       ///< Sell.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(OrderSide::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, OrderSide::Enum);

/// Ownership indicator.
struct ONIXS_EUREX_ETI_EXPORT OwnershipIndicator
{
    /// \copydoc OwnershipIndicator
    enum Enum
    {
        NoValue = 0xFF,              ///< No value.
        NoChangeOfOwnership = 0,     ///< Do not change ownership.
        ChangeToExecutingTrader = 1, ///< Change ownership to executing party (User ID).
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(OwnershipIndicator::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, OwnershipIndicator::Enum);

/// Party action type.
struct ONIXS_EUREX_ETI_EXPORT PartyActionType
{
    /// \copydoc PartyActionType
    enum Enum
    {
        NoValue = 0xFF,  ///< No value.
        HaltTrading = 1, ///< Halt trading.
        Reinstate = 2,   ///< Reinstate.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(PartyActionType::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, PartyActionType::Enum);

/// Party detail role qualifier.
struct ONIXS_EUREX_ETI_EXPORT PartyDetailRoleQualifier
{
    /// \copydoc PartyDetailRoleQualifier
    enum Enum
    {
        NoValue = 0xFF,  ///< No value.
        Trader = 10,     ///< Trader.
        HeadTrader = 11, ///< Head Trader.
        Supervisor = 12, ///< Supervisor.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(PartyDetailRoleQualifier::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, PartyDetailRoleQualifier::Enum);

/// Party detail status.
struct ONIXS_EUREX_ETI_EXPORT PartyDetailStatus
{
    /// \copydoc PartyDetailStatus
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        Active = 0,     ///< Active.
        Suspend = 1,    ///< Suspend.
        Rejected = 2,   ///< Rejected.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(PartyDetailStatus::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, PartyDetailStatus::Enum);

/// Reason for a responder reject.
struct ONIXS_EUREX_ETI_EXPORT PartyDetailStatusInformation
{
    /// \copydoc PartyDetailStatusInformation
    enum Enum
    {
        NoValue = 0xFF,         ///< No value.
        TRRTHRESHOLDTOOBIG = 1, ///< High TRR (TradeToRequestRatio) threshold.
        BLOCKALLANONYMOUS = 2,  ///< Anonymous negotiation blocked by responder.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(PartyDetailStatusInformation::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, PartyDetailStatusInformation::Enum);

/// Entering Business Unit.
struct ONIXS_EUREX_ETI_EXPORT PartyIdEnteringFirm
{
    /// \copydoc PartyIdEnteringFirm
    enum Enum
    {
        NoValue = 0xFF,        ///< No value.
        Participant = 1,       ///< Participant.
        MarketSupervision = 2, ///< Market Supervision.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(PartyIdEnteringFirm::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, PartyIdEnteringFirm::Enum);

/// Party ID origination market.
struct ONIXS_EUREX_ETI_EXPORT PartyIdOriginationMarket
{
    /// \copydoc PartyIdOriginationMarket
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        XKFE = 1,       ///< Korea Exchange.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(PartyIdOriginationMarket::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, PartyIdOriginationMarket::Enum);

/// Settlement institution.
struct ONIXS_EUREX_ETI_EXPORT PartyIdSettlementLocation
{
    /// \copydoc PartyIdSettlementLocation
    enum Enum
    {
        NoValue = 0xFF,                 ///< No value.
        ClearstremBankingFrankfurt = 1, ///< Clearstrem Banking Frankfurt.
        ClearstremBankingLuxemburg = 2, ///< Clearstrem Banking Luxemburg.
        CLSGroup = 3,                   ///< CLS Group.
        Euroclear = 4,                  ///< Euroclear.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(PartyIdSettlementLocation::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, PartyIdSettlementLocation::Enum);

/// Party ID investment decision maker qualifier.
struct ONIXS_EUREX_ETI_EXPORT PartyIdInvestmentDecisionMakerQualifier
{
    /// \copydoc PartyIdInvestmentDecisionMakerQualifier
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        Algo = 22,      ///< Algo.
        Human = 24,     ///< Human/Natural person.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(PartyIdInvestmentDecisionMakerQualifier::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, PartyIdInvestmentDecisionMakerQualifier::Enum);

/// Instruction to show buy-side user information.
struct ONIXS_EUREX_ETI_EXPORT PartyOrderOriginationDisclosureInstruction
{
    /// \copydoc PartyOrderOriginationDisclosureInstruction
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        No = 0,         ///< No.
        Yes = 1,        ///< Yes.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(PartyOrderOriginationDisclosureInstruction::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, PartyOrderOriginationDisclosureInstruction::Enum);

/// Party sub-type.
struct ONIXS_EUREX_ETI_EXPORT PartySubIdType
{
    /// \copydoc PartySubIdType
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        Buyer = 14001,  ///< Buyer.
        Seller = 14002, ///< Seller.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(PartySubIdType::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, PartySubIdType::Enum);

/// Field is used for Eurex position management purposes and indicates whether the order is submitted to open or close a
/// position.
struct ONIXS_EUREX_ETI_EXPORT PositionEffect
{
    /// \copydoc PositionEffect
    enum Enum
    {
        NoValue = 0x00, ///< No value.
        Close = 'C',    ///< Close.
        Open = 'O',     ///< Open.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(PositionEffect::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, PositionEffect::Enum);

/// Price disclosure instruction.
struct ONIXS_EUREX_ETI_EXPORT PriceDisclosureInstruction
{
    /// \copydoc PriceDisclosureInstruction
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        No = 0,         ///< No.
        Yes = 1,        ///< Yes.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(PriceDisclosureInstruction::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, PriceDisclosureInstruction::Enum);

/// Indicator how price validity check should be performed by the exchange.
struct ONIXS_EUREX_ETI_EXPORT PriceValidityCheckType
{
    /// \copydoc PriceValidityCheckType
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        None = 0,       ///< None.
        Optional = 1,   ///< Optional.
        Mandatory = 2,  ///< Mandatory.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(PriceValidityCheckType::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, PriceValidityCheckType::Enum);

/// This field qualifies an instrument type on Eurex.
struct ONIXS_EUREX_ETI_EXPORT ProductComplex
{
    /// \copydoc ProductComplex
    enum Enum
    {
        NoValue = 0xFF,                     ///< No value.
        SimpleInstrument = 1,               ///< Simple instrument.
        StandardOptionStrategy = 2,         ///< Standard Option Strategy.
        NonStandardOptionStrategy = 3,      ///< Non-Standard Option Strategy.
        VolatilityStrategy = 4,             ///< Volatility Strategy.
        FuturesSpread = 5,                  ///< Futures Spread.
        InterProductSpread = 6,             ///< Inter-Product Spread.
        StandardFutureStrategy = 7,         ///< Standard Future Strategy.
        PackAndBundle = 8,                  ///< Pack and Bundle.
        Strip = 9,                          ///< Strip.
        FlexibleSimpleInstrument = 10,      ///< Flexible Simple Instrument.
        CommodityStrip = 11,                ///< Commodity Strip.
        ScaledSimpleInstrument = 12,        ///< Scaled Simple Instrument.
        NonStandardVolatilityStrategy = 13, ///< Non-Standard Volatility Strategy.
        TotalReturnFutureStrategy = 14,     ///< Total Return Future Strategy.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(ProductComplex::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, ProductComplex::Enum);

/// Indicates whether an option contract is a put or call.
struct ONIXS_EUREX_ETI_EXPORT PutOrCall
{
    /// \copydoc PutOrCall
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        Put = 0,        ///< Put.
        Call = 1,       ///< Call.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(PutOrCall::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, PutOrCall::Enum);

/// Reason for quote cancellation.
struct ONIXS_EUREX_ETI_EXPORT QuoteCancelReason
{
    /// \copydoc QuoteCancelReason
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        Expired = 5,    ///< Expired.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(QuoteCancelReason::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, QuoteCancelReason::Enum);

/// Status of the quote.
struct ONIXS_EUREX_ETI_EXPORT QuoteCondition
{
    /// \copydoc QuoteCondition
    enum Enum
    {
        NoValue = 0x00,  ///< No value.
        Active = 'A',    ///< Active.
        Closed = 'B',    ///< Closed.
        Suspended = 'z', ///< Suspended.
        Expired = '8',   ///< Expired.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(QuoteCondition::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, QuoteCondition::Enum);

/// Reason code indicating why the quote entry has been rejected.
struct ONIXS_EUREX_ETI_EXPORT QuoteEntryRejectReason
{
    /// \copydoc QuoteEntryRejectReason
    enum Enum
    {
        NoValue = 0xFF,                                    ///< No value.
        UnknownSecurity = 1,                               ///< Unknown security.
        DuplicateQuote = 6,                                ///< Duplicate quote.
        InvalidPrice = 8,                                  ///< Invalid price.
        NoReferencePriceAvailable = 16,                    ///< Reference price not available.
        NoSingleSidedQuotes = 100,                         ///< Single sided quotes not allowed.
        InvalidQuotingModel = 103,                         ///< Invalid usage of quoting model.
        InvalidSize = 106,                                 ///< Invalid size.
        InvalidUnderlyingPrice = 107,                      ///< Invalid underlying price.
        BidPriceNotReasonable = 108,                       ///< Bid price not reasonable.
        AskPriceNotReasonable = 109,                       ///< Ask price not reasonable.
        BidPriceExceedsRange = 110,                        ///< Bid price exceeds extended price range.
        AskPriceExceedsRange = 111,                        ///< Ask price exceeds extended price range.
        InstrumentStateFreeze = 115,                       ///< Instrument state freeze.
        DeletionAlreadyPending = 116,                      ///< Deletion already pending.
        EntitlementNotAssignedForUnderlying = 119,         ///< Entitlement not assigned for underlying.
        CurrentlyNotTradeableOnBook = 124,                 ///< Instrument is currently not tradeable on book.
        QuantityLimitExceeded = 125,                       ///< Quantity exceeds trader specific limit.
        ValueLimitExceeded = 126,                          ///< Value exceeds trader specific limit.
        InvalidQuoteSpread = 127,                          ///< Invalid quote spread.
        BookOrCancel = 128,                                ///< Book-or-Cancel quote type.
        CantProcInCurrInstrState = 131,                    ///< Instrument state does not allow processing.
        InvalidQuoteType = 134,                            ///< Invalid quote type.
        TradingIndicationRunningForTrader = 143,           ///< Trading indication running for trader.
        OnBookTradingDisabledForInstrumentType = 144,      ///< On-Book trading disabled for instrument type.
        LiquidityProviderProtectionBidSideCancelled = 147, ///< Liquidity provider protection bid side cancelled.
        LiquidityProviderProtectionAskSideCancelled = 148, ///< Liquidity provider protection ask side cancelled.
        OutsideQuotingPeriod = 155,                        ///< Quote entry outside quoting period not allowed.
        MatchPriceNotOnPriceStep = 156, ///< Match price resulting from entry of the matching quote is not a valid price
                                        ///< step.
        QuantityLimitExceedsTSL = 161,  ///< Quantity exceeds transaction size limit.
        TooManyOrdersAndQuotesInOrderBook = 163,                  ///< Too many orders and quotes in order book.
        ContractCannotBeTradedDueToInsufficientEligibility = 166, ///< Contract cannot be traded due to insufficient
                                                                  ///< eligibility.
        UnderlyingPriceTimeout = 167,       ///< the VF underlying price timed out, rejection of quote.
        BUSuspendARPLevel3SoftBreach = 168, ///< the BU is suspended due to an ARP level 3 soft breach.
        NoClearingProductAssignment = 169,  ///< incoming quote pair rejected due to no clearing product assignment.
        ValueLimitExceededProduct = 170,    ///< Value exceeds Product specific limit.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(QuoteEntryRejectReason::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, QuoteEntryRejectReason::Enum);

/// Identifies the status of an individual quote.
struct ONIXS_EUREX_ETI_EXPORT QuoteEntryStatus
{
    /// \copydoc QuoteEntryStatus
    enum Enum
    {
        NoValue = 0xFF,         ///< No value.
        Accepted = 0,           ///< Accepted with warning.
        Rejected = 5,           ///< Rejected.
        RemovedAndRejected = 6, ///< Removed from Market.
        Pending = 10,           ///< Pending.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(QuoteEntryStatus::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, QuoteEntryStatus::Enum);

/// Indicates whether the quote added or removed liquidity.
struct ONIXS_EUREX_ETI_EXPORT QuoteEventLiquidityInd
{
    /// \copydoc QuoteEventLiquidityInd
    enum Enum
    {
        NoValue = 0xFF,       ///< No value.
        AddedLiquidity = 1,   ///< Added Liquidity.
        RemovedLiquidity = 2, ///< Removed Liquidity.
        Auction = 4,          ///< Auction.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(QuoteEventLiquidityInd::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, QuoteEventLiquidityInd::Enum);

/// Additional information why quote side was removed.
struct ONIXS_EUREX_ETI_EXPORT QuoteEventReason
{
    /// \copydoc QuoteEventReason
    enum Enum
    {
        NoValue = 0xFF,                   ///< No value.
        PendingCancellationExecuted = 14, ///< Pending Cancellation Executed.
        InvalidPrice = 15,                ///< Invalid Price.
        CrossRejected = 16,               ///< Quote subject to crossing and match prevented.
        BookOrCancel = 17,                ///< Quote deleted due to Book-or-Cancel quote type.
        PLP = 18,                         ///< Quote deleted due to passive liquidity protection.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(QuoteEventReason::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, QuoteEventReason::Enum);

/// Side of the quote.
struct ONIXS_EUREX_ETI_EXPORT QuoteEventSide
{
    /// \copydoc QuoteEventSide
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        Buy = 1,        ///< Buy.
        Sell = 2,       ///< Sell.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(QuoteEventSide::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, QuoteEventSide::Enum);

/// Conveys the quote event type.
struct ONIXS_EUREX_ETI_EXPORT QuoteEventType
{
    /// \copydoc QuoteEventType
    enum Enum
    {
        NoValue = 0xFF,        ///< No value.
        ModifiedQuoteSide = 2, ///< Modified side.
        RemovedQuoteSide = 3,  ///< Removed Quote Side.
        PartiallyFilled = 4,   ///< Partially Filled.
        Filled = 5,            ///< Filled.
        RemovedQuantity = 6,   ///< Quantity removed.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(QuoteEventType::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, QuoteEventType::Enum);

/// Quoting instruction.
struct ONIXS_EUREX_ETI_EXPORT QuoteInstruction
{
    /// \copydoc QuoteInstruction
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        DoNotQuote = 0, ///< Do not re-quote.
        Quote = 1,      ///< (Re-)Quote.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(QuoteInstruction::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, QuoteInstruction::Enum);

/// Identifies the quoting model.
struct ONIXS_EUREX_ETI_EXPORT QuoteSizeType
{
    /// \copydoc QuoteSizeType
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        TotalSize = 1,  ///< Total Size (Quote Modification).
        OpenSize = 2,   ///< Open Size(Quote Entry).
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(QuoteSizeType::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, QuoteSizeType::Enum);

/// Sub-type or qualifier of QuoteType.
struct ONIXS_EUREX_ETI_EXPORT QuoteSubType
{
    /// \copydoc QuoteSubType
    enum Enum
    {
        NoValue = 0xFF,                         ///< No value.
        WorkingDelta = 1,                       ///< Working Delta.
        BasisTrade = 2,                         ///< Basis Trade.
        Regular = 3,                            ///< Regular LDS Negotiation.
        NegotiateUnderlyingOutsideExchange = 4, ///< Negotiate the underlying outside the exchange.
        VolaStrategyFix = 5,                    ///< Option Volatility Strategy with fixed Underlying price and delta.
        VolaStrategyNegotiateUnderlying = 6,    ///< Option Volatility Strategy - Underlying price is negotiated on
                                                ///< exchange.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(QuoteSubType::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, QuoteSubType::Enum);

/// Quote type.
struct ONIXS_EUREX_ETI_EXPORT QuoteType
{
    /// \copydoc QuoteType
    enum Enum
    {
        NoValue = 0xFF,     ///< No value.
        Indicative = 0,     ///< Indicative (for Continuous Auction Issuer trading model and Eurex/Xetra EnLight only).
        Tradeable = 1,      ///< Tradeable.
        TradeableBOC = 100, ///< Tradeable(BOC).
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(QuoteType::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, QuoteType::Enum);

/// Quoting status for the executing party.
struct ONIXS_EUREX_ETI_EXPORT QuotingStatus
{
    /// \copydoc QuotingStatus
    enum Enum
    {
        NoValue = 0xFF,     ///< No value.
        OpenActive = 1,     ///< Open/Active.
        OpenIdle = 2,       ///< Open/Working.
        ClosedInactive = 3, ///< Closed/Inactive.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(QuotingStatus::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, QuotingStatus::Enum);

/// Reference to the unique application identifier.
struct ONIXS_EUREX_ETI_EXPORT RefApplId
{
    /// \copydoc RefApplId
    enum Enum
    {
        NoValue = 0xFF,                 ///< No value.
        Trade = 1,                      ///< Trade.
        News = 2,                       ///< News.
        ServiceAvailability = 3,        ///< Service Availability.
        SessionData = 4,                ///< Session Data.
        ListenerData = 5,               ///< Listener Data.
        RiskControl = 6,                ///< Risk Control.
        TESMaintenance = 7,             ///< TES Maintenance.
        TESTrade = 8,                   ///< TES Trade.
        SRQSMaintenance = 9,            ///< SRQS Maintenance.
        ServiceAvailabilityMarket = 10, ///< Service Availability Market.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(RefApplId::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, RefApplId::Enum);

/// Instrument type of the original Eurex strategy.
struct ONIXS_EUREX_ETI_EXPORT RelatedProductComplex
{
    /// \copydoc RelatedProductComplex
    enum Enum
    {
        NoValue = 0xFF,                     ///< No value.
        StandardOptionStrategy = 2,         ///< Standard Option Strategy.
        NonStandardOptionStrategy = 3,      ///< Non-Standard Option Strategy.
        VolatilityStrategy = 4,             ///< Volatility Strategy.
        FuturesSpread = 5,                  ///< Futures Spread.
        InterProductSpread = 6,             ///< Inter-Product Spread.
        StandardFutureStrategy = 7,         ///< Standard Future Strategy.
        PackAndBundle = 8,                  ///< Pack and Bundle.
        Strip = 9,                          ///< Strip.
        CommodityStrip = 11,                ///< Commodity Strip.
        ScaledSimpleInstrument = 12,        ///< Scaled Simple Instrument.
        NonStandardVolatilityStrategy = 13, ///< Non-Standard Volatility Strategy.
        TotalReturnFutureStrategy = 14,     ///< Total Return Future Strategy.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(RelatedProductComplex::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, RelatedProductComplex::Enum);

/// Requesting party ID entering firm.
struct ONIXS_EUREX_ETI_EXPORT RequestingPartyIdEnteringFirm
{
    /// \copydoc RequestingPartyIdEnteringFirm
    enum Enum
    {
        NoValue = 0xFF,        ///< No value.
        Participant = 1,       ///< Participant.
        MarketSupervision = 2, ///< Market Supervision.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(RequestingPartyIdEnteringFirm::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, RequestingPartyIdEnteringFirm::Enum);

/// System ID (1 = Eurex Clearing).
struct ONIXS_EUREX_ETI_EXPORT RequestingPartyIdExecutingSystem
{
    /// \copydoc RequestingPartyIdExecutingSystem
    enum Enum
    {
        NoValue = 0xFF,    ///< No value.
        EurexClearing = 1, ///< Eurex Clearing.
        T7 = 2,            ///< T7 trading system.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(RequestingPartyIdExecutingSystem::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, RequestingPartyIdExecutingSystem::Enum);

/// Party type initiating SRQS deal deletion.
struct ONIXS_EUREX_ETI_EXPORT RequestingPartySubIdType
{
    /// \copydoc RequestingPartySubIdType
    enum Enum
    {
        NoValue = 0xFF,   ///< No value.
        Requester = 5000, ///< Requester.
        Responder = 5001, ///< Responder.
        Both = 5002,      ///< Both (Requester and Responder).
        System = 5003,    ///< System.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(RequestingPartySubIdType::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, RequestingPartySubIdType::Enum);

/// Specifies the type of respondents requested.
struct ONIXS_EUREX_ETI_EXPORT RespondentType
{
    /// \copydoc RespondentType
    enum Enum
    {
        NoValue = 0xFF,            ///< No value.
        AllMarketParticipants = 1, ///< Respondents are known during a negotiation.
        Anonymous = 102, ///< Respondents are anonymized after negotiation start, Requester will remain anonymous from
                         ///< start.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(RespondentType::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, RespondentType::Enum);

/// Reversal cancellation reason.
struct ONIXS_EUREX_ETI_EXPORT ReversalCancellationReason
{
    /// \copydoc ReversalCancellationReason
    enum Enum
    {
        NoValue = 0xFF,           ///< No value.
        TASChange = 1,            ///< TES Activity State Change.
        IntradayExpiration = 2,   ///< Instrument Expiration.
        InstrumentDeletion = 3,   ///< Instrument Deletion.
        InstrumentSuspension = 4, ///< Instrument Suspension.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(ReversalCancellationReason::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, ReversalCancellationReason::Enum);

/// Indicator whether the reversal of the TES trade is electronically requested or not.
struct ONIXS_EUREX_ETI_EXPORT ReversalIndicator
{
    /// \copydoc ReversalIndicator
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        No = 0,         ///< No.
        Yes = 1,        ///< Yes.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(ReversalIndicator::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, ReversalIndicator::Enum);

/// State of the Risk Control Retransmission Service.
struct ONIXS_EUREX_ETI_EXPORT RiskControlRtmServiceStatus
{
    /// \copydoc RiskControlRtmServiceStatus
    enum Enum
    {
        NoValue = 0xFF,  ///< No value.
        Unavailable = 0, ///< Unavailable.
        Available = 1,   ///< Available.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(RiskControlRtmServiceStatus::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, RiskControlRtmServiceStatus::Enum);

/// Risk limit action.
struct ONIXS_EUREX_ETI_EXPORT RiskLimitAction
{
    /// \copydoc RiskLimitAction
    enum Enum
    {
        NoValue = 0xFF,   ///< No value.
        QueueInbound = 0, ///< Queue Inbound.
        Reject = 2,       ///< Reject.
        Warning = 4,      ///< Warning.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(RiskLimitAction::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, RiskLimitAction::Enum);

/// Scope for Pre-Trade risk limits.
struct ONIXS_EUREX_ETI_EXPORT RiskLimitPlatform
{
    /// \copydoc RiskLimitPlatform
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        OnBook = 0,     ///< On-Book.
        OffBook = 1,    ///< Off-Book(TES).
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(RiskLimitPlatform::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, RiskLimitPlatform::Enum);

/// Requesting party role for a pre-trade risk limit.
struct ONIXS_EUREX_ETI_EXPORT RiskLimitRequestingPartyRole
{
    /// \copydoc RiskLimitRequestingPartyRole
    enum Enum
    {
        NoValue = 0xFF,     ///< No value.
        ClearingFirm = 4,   ///< requested by Clearing firm.
        Exchange = 22,      ///< requested by Exchange.
        ExecutingUnit = 59, ///< requested by Executing firm.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(RiskLimitRequestingPartyRole::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, RiskLimitRequestingPartyRole::Enum);

/// Risk Limit Result for failed events.
struct ONIXS_EUREX_ETI_EXPORT RiskLimitResult
{
    /// \copydoc RiskLimitResult
    enum Enum
    {
        NoValue = 0xFF,         ///< No value.
        DisabledForBu = 10580,  ///< Margin Based Risk Limits not enabled for business unit.
        LowRRAEventID = 10581,  ///< Received Remaining Risk Allowance event ID is lower than lowest entry in Temporary
                                ///< Transaction List.
        HighRRAEventID = 10582, ///< Received Remaining Risk Allowance event ID exceeds last entry in Temporary
                                ///< Transaction List.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(RiskLimitResult::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, RiskLimitResult::Enum);

/// Type of risk limits.
struct ONIXS_EUREX_ETI_EXPORT RiskLimitType
{
    /// \copydoc RiskLimitType
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        LongLimit = 4,  ///< Long limit.
        ShortLimit = 5, ///< Short limit.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(RiskLimitType::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, RiskLimitType::Enum);

/// Indicator for a pre-trade risk limit violation.
struct ONIXS_EUREX_ETI_EXPORT RiskLimitViolationIndicator
{
    /// \copydoc RiskLimitViolationIndicator
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        No = 0,         ///< No.
        Yes = 1,        ///< Yes.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(RiskLimitViolationIndicator::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, RiskLimitViolationIndicator::Enum);

/// Qualifier for field PartyIdInvestmentDecisionMaker. Members/participants will have the possibility to specify an
/// Investment qualifier value to distinguish between natural persons and Algos.
struct ONIXS_EUREX_ETI_EXPORT RootPartyIdInvestmentDecisionMakerQualifier
{
    /// \copydoc RootPartyIdInvestmentDecisionMakerQualifier
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        Algo = 22,      ///< Algo.
        Human = 24,     ///< Human/Natural person.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(RootPartyIdInvestmentDecisionMakerQualifier::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, RootPartyIdInvestmentDecisionMakerQualifier::Enum);

/// RootParty sub-type.
struct ONIXS_EUREX_ETI_EXPORT RootPartySubIdType
{
    /// \copydoc RootPartySubIdType
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        Buyer = 4001,   ///< Buyer.
        Seller = 4002,  ///< Seller.
        Broker = 4003,  ///< Broker.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(RootPartySubIdType::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, RootPartySubIdType::Enum);

/// Status of Secondary ETI Gateway.
struct ONIXS_EUREX_ETI_EXPORT SecondaryGatewayStatus
{
    /// \copydoc SecondaryGatewayStatus
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        Standby = 0,    ///< Standby.
        Active = 1,     ///< Active.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(SecondaryGatewayStatus::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, SecondaryGatewayStatus::Enum);

/// State of the Selective Service for Quote Retransmission Service.
struct ONIXS_EUREX_ETI_EXPORT SelectiveRequestForQuoteRtmServiceStatus
{
    /// \copydoc SelectiveRequestForQuoteRtmServiceStatus
    enum Enum
    {
        NoValue = 0xFF,  ///< No value.
        Unavailable = 0, ///< Unavailable.
        Available = 1,   ///< Available.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(SelectiveRequestForQuoteRtmServiceStatus::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, SelectiveRequestForQuoteRtmServiceStatus::Enum);

/// State of the selective service for quote service.
struct ONIXS_EUREX_ETI_EXPORT SelectiveRequestForQuoteServiceStatus
{
    /// \copydoc SelectiveRequestForQuoteServiceStatus
    enum Enum
    {
        NoValue = 0xFF,  ///< No value.
        Unavailable = 0, ///< Unavailable.
        Available = 1,   ///< Available.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(SelectiveRequestForQuoteServiceStatus::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, SelectiveRequestForQuoteServiceStatus::Enum);

/// Indicate the instruction for SMP. If MatchInstCrossID (28744) is set then the default value for
/// SelfMatchPreventionInstruction is 100 (Reject cross on business unit level).
struct ONIXS_EUREX_ETI_EXPORT SelfMatchPreventionInstruction
{
    /// \copydoc SelfMatchPreventionInstruction
    enum Enum
    {
        NoValue = 0xFF,            ///< No value.
        CrossRejectedBU = 100,     ///< Reject cross on business unit level.
        CrossRejectedMarket = 101, ///< Reject cross on market level.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(SelfMatchPreventionInstruction::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, SelfMatchPreventionInstruction::Enum);

/// Type of Eurex ETI session.
struct ONIXS_EUREX_ETI_EXPORT SessionMode
{
    /// \copydoc SessionMode
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        ETIHF = 1,      ///< ETI HF.
        ETILF = 2,      ///< ETI LF.
        GUI = 3,        ///< GUI.
        FIXLF = 4,      ///< FIX LF.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(SessionMode::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, SessionMode::Enum);

/// Error code.
struct ONIXS_EUREX_ETI_EXPORT SessionRejectReason
{
    /// \copydoc SessionRejectReason
    enum Enum
    {
        NoValue = 0xFF,                             ///< No value.
        RequiredTagMissing = 1,                     ///< Required Tag Missing.
        ValueIsIncorrect = 5,                       ///< Value is incorrect (out of range) for this tag.
        DecryptionProblem = 7,                      ///< Decryption problem.
        InvalidMsgID = 11,                          ///< Invalid TemplateID.
        IncorrectNumInGroupCount = 16,              ///< Incorrect NumInGroup count for repeating group.
        Other = 99,                                 ///< Other.
        ThrottleLimitExceeded = 100,                ///< Throttle limit exceeded.
        ExposureLimitExceeded = 101,                ///< Stale request was not forwarded to T7.
        ServiceTemporarilyNotAvailable = 102,       ///< Service temporarily not available.
        ServiceNotAvailable = 103,                  ///< Service not available.
        OutboundConversionError = 105,              ///< Error converting response or broadcast.
        HeartbeatViolation = 152,                   ///< Heartbeat violation error.
        InternalTechnicalError = 200,               ///< Internal technical error.
        ValidationError = 210,                      ///< Validation Error.
        UserAlreadyLoggedIn = 211,                  ///< User already logged in.
        GatewayIsStandby = 216,                     ///< Gateway is standby.
        SessionLoginLimitReached = 217,             ///< Session login limit (per time interval) reached.
        UserEntitlementDataTimeout = 223,           ///< User Entitlement Data time out.
        PSGatewaySessionLimitReached = 224,         ///< Session limit reached (per PS Gateway and Business Unit).
        UserLoginLimitReached = 225,                ///< User login tries limit (per time interval) reached.
        OutstandingLoginsBuLimitReached = 226,      ///< Limit of outstanding session/user logins reached (per Business
                                                    ///< Unit).
        OutstandingLoginsSessionLimitReached = 227, ///< Limit of outstanding session/user logins reached (per Session).
        PasswordTimestampNotInGracePeriod = 228,    ///< Password timestamp not in grace period.
        OrderNotFound = 10000,                      ///< Order not found.
        PriceNotReasonable = 10001,                 ///< Price not reasonable.
        ClientOrderIDNotUnique = 10002,             ///< Duplicate Order (ClOrdID).
        QuoteActivationInProgress = 10003, ///< another quote activation request is pending for the same Product /
                                           ///< Instrument Type / SessionID.
        StopBidPriceNotReasonable = 10006, ///< Stop buy price not reasonable.
        StopAskPriceNotReasonable = 10007, ///< Stop sell price not reasonable.
        OrderNotExecutableWithinValidity = 10008,    ///< GFD order is not executable on current business day.
        CreateCIThrottleExceeded = 10010,            ///< Throttle limit for creation of complex instrument exceeded.
        TransactionNotAllowedInCurrentState = 10011, ///< Order maintenance not allowed in current state.
        RequiredMinLotSizeNotReached = 10013,        ///< Required min lot size not reached.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(SessionRejectReason::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, SessionRejectReason::Enum);

/// Status of an ETI session.
struct ONIXS_EUREX_ETI_EXPORT SessionStatus
{
    /// \copydoc SessionStatus
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        Active = 0,     ///< Session active.
        Logout = 4,     ///< Session logout complete.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(SessionStatus::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, SessionStatus::Enum);

/// Session sub mode.
struct ONIXS_EUREX_ETI_EXPORT SessionSubMode
{
    /// \copydoc SessionSubMode
    enum Enum
    {
        NoValue = 0xFF,               ///< No value.
        RegularTradingSession = 0,    ///< Regular Trading Session.
        RegularBackOfficeSession = 2, ///< Regular Back Office Session.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(SessionSubMode::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, SessionSubMode::Enum);

/// Settlement method for a contract or instrument.
struct ONIXS_EUREX_ETI_EXPORT SettlMethod
{
    /// \copydoc SettlMethod
    enum Enum
    {
        NoValue = 0x00,           ///< No value.
        CashSettlement = 'C',     ///< Cash Settlement.
        PhysicalSettlement = 'P', ///< Physical Settlement.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(SettlMethod::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, SettlMethod::Enum);

/// Instruction to show last deal information after negotiation closure.
struct ONIXS_EUREX_ETI_EXPORT ShowLastDealOnClosure
{
    /// \copydoc ShowLastDealOnClosure
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        No = 0,         ///< No.
        Yes = 1,        ///< Yes.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(ShowLastDealOnClosure::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, ShowLastDealOnClosure::Enum);

/// Side of the order.
struct ONIXS_EUREX_ETI_EXPORT Side
{
    /// \copydoc Side
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        Buy = 1,        ///< Buy.
        Sell = 2,       ///< Sell.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(Side::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, Side::Enum);

/// Instruction to show side.
struct ONIXS_EUREX_ETI_EXPORT SideDisclosureInstruction
{
    /// \copydoc SideDisclosureInstruction
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        No = 0,         ///< No.
        Yes = 1,        ///< Yes.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(SideDisclosureInstruction::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, SideDisclosureInstruction::Enum);

/// Side is locked.
struct ONIXS_EUREX_ETI_EXPORT SideIsLocked
{
    /// \copydoc SideIsLocked
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        No = 0,         ///< No.
        Yes = 1,        ///< Yes.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(SideIsLocked::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, SideIsLocked::Enum);

/// Order initiator is passive or aggressor.
struct ONIXS_EUREX_ETI_EXPORT SideLiquidityInd
{
    /// \copydoc SideLiquidityInd
    enum Enum
    {
        NoValue = 0xFF,       ///< No value.
        AddedLiquidity = 1,   ///< Added liquidity (passive).
        RemovedLiquidity = 2, ///< Removed liquidity (aggressive, includes triggered orders).
        Auction = 4,          ///< Auction.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(SideLiquidityInd::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, SideLiquidityInd::Enum);

/// Sub-type of a trade type.
struct ONIXS_EUREX_ETI_EXPORT SideTrdSubTyp
{
    /// \copydoc SideTrdSubTyp
    enum Enum
    {
        NoValue = 0xFF,       ///< No value.
        BlockTrade = 2001,    ///< Block Trade.
        TradeAtMarket = 2004, ///< Trade at Market.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(SideTrdSubTyp::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, SideTrdSubTyp::Enum);

/// Indicator to skip validations.
struct ONIXS_EUREX_ETI_EXPORT SkipValidations
{
    /// \copydoc SkipValidations
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        False = 0,      ///< False.
        True = 1,       ///< True.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(SkipValidations::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, SkipValidations::Enum);

/// Swap clearer for EFS Trades only.
struct ONIXS_EUREX_ETI_EXPORT SwapClearer
{
    /// \copydoc SwapClearer
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        ECAG = 0,       ///< Eurex Clearing.
        NONECAG = 1,    ///< Non-Eurex Clearing.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(SwapClearer::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, SwapClearer::Enum);

/// Informs if Trade Entry Retransmission Service is active for grouping of Eurex products.
struct ONIXS_EUREX_ETI_EXPORT T7EntryServiceRtmStatus
{
    /// \copydoc T7EntryServiceRtmStatus
    enum Enum
    {
        NoValue = 0xFF,  ///< No value.
        Unavailable = 0, ///< Unavailable.
        Available = 1,   ///< Available.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(T7EntryServiceRtmStatus::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, T7EntryServiceRtmStatus::Enum);

/// Informs if Trade Entry Service is active for grouping of Eurex products.
struct ONIXS_EUREX_ETI_EXPORT T7EntryServiceStatus
{
    /// \copydoc T7EntryServiceStatus
    enum Enum
    {
        NoValue = 0xFF,  ///< No value.
        Unavailable = 0, ///< Unavailable.
        Available = 1,   ///< Available.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(T7EntryServiceStatus::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, T7EntryServiceStatus::Enum);

/// Execution and trading restriction parameters supported by Eurex.
struct ONIXS_EUREX_ETI_EXPORT TimeInForce
{
    /// \copydoc TimeInForce
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        Day = 0,        ///< Day (GFD).
        GTC = 1,        ///< Good Till Cancelled (GTC) - Standard Orders only.
        IOC = 3,        ///< Immediate or Cancel (IOC).
        FOK = 4,        ///< Fill Or Kill (FOK).
        GTD = 6,        ///< Good Till Date (GTD) - Standard Orders only.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(TimeInForce::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, TimeInForce::Enum);

/// Trading session event type.
struct ONIXS_EUREX_ETI_EXPORT TradSesEvent
{
    /// \copydoc TradSesEvent
    enum Enum
    {
        NoValue = 0xFF,         ///< No value.
        StartOfService = 101,   ///< Start of Service.
        MarketReset = 102,      ///< Market Reset.
        EndOfRestatement = 103, ///< End of Restatement.
        EndOfDayService = 104,  ///< End of Service.
        ServiceResumed = 105,   ///< Service Resumed.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(TradSesEvent::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, TradSesEvent::Enum);

/// Trading session mode.
struct ONIXS_EUREX_ETI_EXPORT TradSesMode
{
    /// \copydoc TradSesMode
    enum Enum
    {
        NoValue = 0xFF,       ///< No value.
        Testing = 1,          ///< Development.
        Simulated = 2,        ///< Simulation.
        Production = 3,       ///< Production.
        Acceptance = 4,       ///< Acceptance.
        DisasterRecovery = 5, ///< Disaster Recovery.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(TradSesMode::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, TradSesMode::Enum);

/// Trade Aggregation Identifier.
struct ONIXS_EUREX_ETI_EXPORT TradeAggregationTransType
{
    /// \copydoc TradeAggregationTransType
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        New = 0,        ///< New.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(TradeAggregationTransType::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, TradeAggregationTransType::Enum);

/// Status of an allocation in a Trade Entry Service trade.
struct ONIXS_EUREX_ETI_EXPORT TradeAllocStatus
{
    /// \copydoc TradeAllocStatus
    enum Enum
    {
        NoValue = 0xFF,         ///< No value.
        Pending = 1,            ///< Pending.
        Approved = 2,           ///< Approved.
        AutoApproved = 3,       ///< Auto Approved.
        Uploaded = 4,           ///< Uploaded.
        Canceled = 5,           ///< Canceled.
        PendingReversal = 7,    ///< Pending Reversal.
        ApprovedReversal = 8,   ///< Side Approved Reversal.
        Reversed = 9,           ///< Reversed.
        CancelledReversal = 10, ///< Cancelled Reversal.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(TradeAllocStatus::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, TradeAllocStatus::Enum);

/// Informs if trade broadcast dissemination is active for a grouping of Eurex products.
struct ONIXS_EUREX_ETI_EXPORT TradeManagerStatus
{
    /// \copydoc TradeManagerStatus
    enum Enum
    {
        NoValue = 0xFF,  ///< No value.
        Unavailable = 0, ///< Unavailable.
        Available = 1,   ///< Available.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(TradeManagerStatus::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, TradeManagerStatus::Enum);

/// Indicates trade platform. Can only be used for EEX.
struct ONIXS_EUREX_ETI_EXPORT TradePlatform
{
    /// \copydoc TradePlatform
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        OffBook = 0,    ///< Off-Book.
        OnBook = 1,     ///< On-Book.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(TradePlatform::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, TradePlatform::Enum);

/// Indicates if a trade should be reported via the market reporting service.
struct ONIXS_EUREX_ETI_EXPORT TradePublishIndicator
{
    /// \copydoc TradePublishIndicator
    enum Enum
    {
        NoValue = 0xFF,          ///< No value.
        DoNotPublishTrade = 0,   ///< Do not publish trade.
        PublishTrade = 1,        ///< Publish trade.
        DeferredPublication = 2, ///< Deferred publication to market.
        Published = 3,           ///< Published to market.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(TradePublishIndicator::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, TradePublishIndicator::Enum);

/// Identifies the type of trade notification.
struct ONIXS_EUREX_ETI_EXPORT TradeReportType
{
    /// \copydoc TradeReportType
    enum Enum
    {
        NoValue = 0xFF,        ///< No value.
        Submit = 0,            ///< Submit.
        Alleged = 1,           ///< Alleged.
        Accept = 2,            ///< Accept.
        Decline = 3,           ///< Decline.
        NoWasReplaced = 5,     ///< No/Was (Replaced).
        TradeReportCancel = 6, ///< Trade Report Cancel.
        TradeBreak = 7,        ///< (Locked-In) Trade Break.
        AllegedNew = 11,       ///< Alleged New.
        AllegedNoWas = 13,     ///< Alleged No/Was.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(TradeReportType::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, TradeReportType::Enum);

/// Trade request transaction type.
struct ONIXS_EUREX_ETI_EXPORT TradeRequestResult
{
    /// \copydoc TradeRequestResult
    enum Enum
    {
        NoValue = 0xFF,       ///< No value.
        CancelPending = 100,  ///< Deal cancellation pending.
        CancelDeclined = 101, ///< Deal cancellation declined.
        CancelApproved = 102, ///< Deal cancellation approved.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(TradeRequestResult::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, TradeRequestResult::Enum);

/// Trade to Quote Ratio (TQR) Ranking.
struct ONIXS_EUREX_ETI_EXPORT TradeToQuoteRatioRanking
{
    /// \copydoc TradeToQuoteRatioRanking
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        Low = 1,        ///< Low.
        Medium = 2,     ///< Medium.
        High = 3,       ///< High.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(TradeToQuoteRatioRanking::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, TradeToQuoteRatioRanking::Enum);

/// This field designates if the trader is acting in the capacity of agent, trading for its own account or acting as a
/// market maker.
struct ONIXS_EUREX_ETI_EXPORT TradingCapacity
{
    /// \copydoc TradingCapacity
    enum Enum
    {
        NoValue = 0xFF,  ///< No value.
        Customer = 1,    ///< Customer (Agency).
        Principal = 5,   ///< Principal (Proprietary).
        MarketMaker = 6, ///< Market Maker.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(TradingCapacity::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, TradingCapacity::Enum);

/// Marks a a certain order as a closing auction one.
struct ONIXS_EUREX_ETI_EXPORT TradingSessionSubId
{
    /// \copydoc TradingSessionSubId
    enum Enum
    {
        NoValue = 0xFF,     ///< No value.
        OpeningAuction = 2, ///< Opening or opening auction.
        ClosingAuction = 4, ///< Closing or closing auction.
        AnyAuction = 8,     ///< Any auction.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(TradingSessionSubId::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, TradingSessionSubId::Enum);

/// Indicator for a delayed transaction.
struct ONIXS_EUREX_ETI_EXPORT TransactionDelayIndicator
{
    /// \copydoc TransactionDelayIndicator
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        NotDelayed = 0, ///< Transaction not delayed.
        Delayed = 1,    ///< Transaction delayed.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(TransactionDelayIndicator::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, TransactionDelayIndicator::Enum);

/// Identifies the role for which the trade notification is received.
struct ONIXS_EUREX_ETI_EXPORT TransferReason
{
    /// \copydoc TransferReason
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        Owner = 1,      ///< Owner.
        Clearer = 2,    ///< Clearer.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(TransferReason::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, TransferReason::Enum);

/// SRQS deal status.
struct ONIXS_EUREX_ETI_EXPORT TrdRptStatus
{
    /// \copydoc TrdRptStatus
    enum Enum
    {
        NoValue = 0xFF,     ///< No value.
        Accepted = 0,       ///< Accepted.
        Rejected = 1,       ///< Rejected.
        Cancelled = 2,      ///< Cancelled.
        PendingNew = 4,     ///< Pending new.
        PendingCancel = 5,  ///< Pending Cancel.
        Terminated = 7,     ///< Terminated.
        DeemedVerified = 9, ///< Deemed verified.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(TrdRptStatus::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, TrdRptStatus::Enum);

/// Indicates if a trade should be reported via the market reporting service.
struct ONIXS_EUREX_ETI_EXPORT TrdType
{
    /// \copydoc TrdType
    enum Enum
    {
        NoValue = 0xFF,                   ///< No value.
        BlockTrade = 1,                   ///< Block Trade.
        ExchangeForSwap = 12,             ///< Exchange for Swap.
        VolaTrade = 1000,                 ///< Vola Trade.
        EFPFinTrade = 1001,               ///< EFP-Fin Trade.
        EFPIndexFuturesTrade = 1002,      ///< EFP-Index Futures Trade.
        TradeAtMarket = 1004,             ///< Trade at Market.
        Enlight = 1006,                   ///< Eurex/Xetra Enlight triggered trade.
        BLOCKQTPIP = 1007,                ///< QTPIP BLOCK TRADE.
        BTRF = 1010,                      ///< Basket of Equity Total Return Futures.
        EBB = 1011,                       ///< Equity Bespoke Baskets.
        DeltaNeutralTradeAtMarket = 1017, ///< Delta Neutral Trade at Market.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(TrdType::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, TrdType::Enum);

/// Indicates if an order has been previously triggered.
struct ONIXS_EUREX_ETI_EXPORT Triggered
{
    /// \copydoc Triggered
    enum Enum
    {
        NoValue = 0xFF,    ///< No value.
        NotTriggered = 0,  ///< Not Triggered.
        TriggeredStop = 1, ///< Triggered Stop.
        TriggeredOCO = 2,  ///< Triggered OCO.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(Triggered::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, Triggered::Enum);

/// User status.
struct ONIXS_EUREX_ETI_EXPORT UserStatus
{
    /// \copydoc UserStatus
    enum Enum
    {
        NoValue = 0xFF,       ///< No value.
        UserForcedLogout = 7, ///< Forced user logout by exchange.
        UserStopped = 10,     ///< Admission to trading suspended .
        UserReleased = 11,    ///< Suspension revoked.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(UserStatus::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, UserStatus::Enum);

/// Indicator for checking the Minimum Lot Size by the exchange. Only used for EEX. Mandatory if TrdRptStatus=4
/// (Pending_New).
struct ONIXS_EUREX_ETI_EXPORT ValueCheckTypeMinLotSize
{
    /// \copydoc ValueCheckTypeMinLotSize
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        DoNotCheck = 0, ///< Do not check.
        Check = 1,      ///< Check.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(ValueCheckTypeMinLotSize::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, ValueCheckTypeMinLotSize::Enum);

/// Indicator for checking the maximum order or quote quantity by the exchange.
struct ONIXS_EUREX_ETI_EXPORT ValueCheckTypeQuantity
{
    /// \copydoc ValueCheckTypeQuantity
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        DoNotCheck = 0, ///< Do not check.
        Check = 1,      ///< Check.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(ValueCheckTypeQuantity::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, ValueCheckTypeQuantity::Enum);

/// Indicator for checking the maximum order/quote value by the exchange.
struct ONIXS_EUREX_ETI_EXPORT ValueCheckTypeValue
{
    /// \copydoc ValueCheckTypeValue
    enum Enum
    {
        NoValue = 0xFF, ///< No value.
        DoNotCheck = 0, ///< Do not check.
        Check = 1,      ///< Check.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(ValueCheckTypeValue::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, ValueCheckTypeValue::Enum);

/// Template IDs.
struct ONIXS_EUREX_ETI_EXPORT TemplateId
{
    /// \copydoc TemplateId
    enum Enum
    {
        Unknown = 0,                                      ///< Unknown.
        AddComplexInstrumentRequest = 10301,              ///< Add Complex Instrument Request.
        AddComplexInstrumentResponse = 10302,             ///< Add Complex Instrument Response.
        AddFlexibleInstrumentRequest = 10309,             ///< Add Flexible Instrument Request.
        AddFlexibleInstrumentResponse = 10310,            ///< Add Flexible Instrument Response.
        AddScaledSimpleInstrumentRequest = 10327,         ///< Add Scaled Simple Instrument Request.
        AddScaledSimpleInstrumentResponse = 10328,        ///< Add Scaled Simple Instrument Response.
        AmendBasketTradeRequest = 10629,                  ///< Amend Basket Trade Request.
        ApproveBasketTradeRequest = 10623,                ///< Approve Basket Trade Request.
        ApproveReverseTESTradeRequest = 10631,            ///< Approve Reverse TES Trade Request.
        ApproveTESTradeRequest = 10603,                   ///< Approve TES Trade Request.
        BasketApproveBroadcast = 10627,                   ///< Basket Approve Broadcast.
        BasketBroadcast = 10625,                          ///< Basket Broadcast.
        BasketDeleteBroadcast = 10626,                    ///< Basket Delete Broadcast.
        BasketExecutionBroadcast = 10628,                 ///< Basket Execution Broadcast.
        BasketResponse = 10624,                           ///< Basket Response.
        BasketRollBroadcast = 10634,                      ///< Basket Roll Broadcast.
        BasketRollRequest = 10633,                        ///< Basket Roll Request.
        BroadcastErrorNotification = 10032,               ///< Broadcast Error Notification.
        CLIPDeletionNotification = 10134,                 ///< CLIP Deletion Notification.
        CLIPExecutionNotification = 10135,                ///< CLIP Execution Notification.
        CLIPResponse = 10133,                             ///< CLIP Response.
        CrossRequest = 10118,                             ///< Cross Request.
        CrossRequestResponse = 10119,                     ///< Cross Request Response.
        DeleteAllOrderBroadcast = 10122,                  ///< Delete All Order Broadcast.
        DeleteAllOrderNRResponse = 10124,                 ///< Delete All Order NR Response.
        DeleteAllOrderQuoteEventBroadcast = 10308,        ///< Delete All Order Quote Event Broadcast.
        DeleteAllOrderRequest = 10120,                    ///< Delete All Order Request.
        DeleteAllOrderResponse = 10121,                   ///< Delete All Order Response.
        DeleteAllQuoteBroadcast = 10410,                  ///< Delete All Quote Broadcast.
        DeleteAllQuoteRequest = 10408,                    ///< Delete All Quote Request.
        DeleteAllQuoteResponse = 10409,                   ///< Delete All Quote Response.
        DeleteBasketTradeRequest = 10622,                 ///< Delete Basket Trade Request.
        DeleteCLIPRequest = 10132,                        ///< Delete CLIP Request.
        DeleteOrderBroadcast = 10112,                     ///< Delete Order Broadcast.
        DeleteOrderComplexRequest = 10123,                ///< Delete Order Complex Request.
        DeleteOrderNRResponse = 10111,                    ///< Delete Order NR Response.
        DeleteOrderRequest = 10142,                       ///< Delete Order Request.
        DeleteOrderResponse = 10110,                      ///< Delete Order Response.
        DeleteOrderSingleRequest = 10109,                 ///< Delete Order Single Request.
        DeleteTESTradeRequest = 10602,                    ///< Delete TES Trade Request.
        EnterBasketTradeRequest = 10620,                  ///< Enter Basket Trade Request.
        EnterCLIPRequest = 10131,                         ///< Enter CLIP Request.
        EnterTESTradeRequest = 10600,                     ///< Enter TES Trade Request.
        ForcedLogoutNotification = 10012,                 ///< Forced Logout Notification.
        ForcedUserLogoutNotification = 10043,             ///< Forced User Logout Notification.
        Heartbeat = 10011,                                ///< Heartbeat.
        HeartbeatNotification = 10023,                    ///< Heartbeat Notification.
        InquireEnrichmentRuleIdListRequest = 10040,       ///< Inquire Enrichment Rule Id List Request.
        InquireEnrichmentRuleIdListResponse = 10041,      ///< Inquire Enrichment Rule Id List Response.
        InquireMMParameterRequest = 10305,                ///< Inquire MM Parameter Request.
        InquireMMParameterResponse = 10306,               ///< Inquire MM Parameter Response.
        InquireMarginBasedRiskLimitRequest = 10323,       ///< Inquire Margin Based Risk Limit Request.
        InquireMarginBasedRiskLimitResponse = 10324,      ///< Inquire Margin Based Risk Limit Response.
        InquirePreTradeRiskLimitsRequest = 10311,         ///< Inquire Pre Trade Risk Limits Request.
        InquireSessionListRequest = 10035,                ///< Inquire Session List Request.
        InquireSessionListResponse = 10036,               ///< Inquire Session List Response.
        InquireUserRequest = 10038,                       ///< Inquire User Request.
        InquireUserResponse = 10039,                      ///< Inquire User Response.
        LegalNotificationBroadcast = 10037,               ///< Legal Notification Broadcast.
        LogonRequest = 10000,                             ///< Logon Request.
        LogonRequestEncrypted = 19000,                    ///< Logon Request Encrypted.
        LogonResponse = 10001,                            ///< Logon Response.
        LogoutRequest = 10002,                            ///< Logout Request.
        LogoutResponse = 10003,                           ///< Logout Response.
        MMParameterDefinitionRequest = 10303,             ///< MM Parameter Definition Request.
        MMParameterDefinitionResponse = 10304,            ///< MM Parameter Definition Response.
        MassOrder = 10115,                                ///< Mass Order.
        MassOrderAck = 10116,                             ///< Mass Order Ack.
        MassQuoteRequest = 10405,                         ///< Mass Quote Request.
        MassQuoteResponse = 10406,                        ///< Mass Quote Response.
        ModifyBasketTradeRequest = 10621,                 ///< Modify Basket Trade Request.
        ModifyOrderComplexRequest = 10114,                ///< Modify Order Complex Request.
        ModifyOrderComplexShortRequest = 10130,           ///< Modify Order Complex Short Request.
        ModifyOrderNRResponse = 10108,                    ///< Modify Order NR Response.
        ModifyOrderRequest = 10140,                       ///< Modify Order Request.
        ModifyOrderResponse = 10107,                      ///< Modify Order Response.
        ModifyOrderShortRequest = 10141,                  ///< Modify Order Short Request.
        ModifyOrderSingleRequest = 10106,                 ///< Modify Order Single Request.
        ModifyOrderSingleShortRequest = 10126,            ///< Modify Order Single Short Request.
        ModifyTESTradeRequest = 10601,                    ///< Modify TES Trade Request.
        NewOrderComplexRequest = 10113,                   ///< New Order Complex Request.
        NewOrderComplexShortRequest = 10129,              ///< New Order Complex Short Request.
        NewOrderNRResponse = 10102,                       ///< New Order NR Response.
        NewOrderRequest = 10138,                          ///< New Order Request.
        NewOrderResponse = 10101,                         ///< New Order Response.
        NewOrderShortRequest = 10139,                     ///< New Order Short Request.
        NewOrderSingleRequest = 10100,                    ///< New Order Single Request.
        NewOrderSingleShortRequest = 10125,               ///< New Order Single Short Request.
        NewsBroadcast = 10031,                            ///< News Broadcast.
        OrderExecNotification = 10104,                    ///< Order Exec Notification.
        OrderExecReportBroadcast = 10117,                 ///< Order Exec Report Broadcast.
        OrderExecResponse = 10103,                        ///< Order Exec Response.
        PartyActionReport = 10042,                        ///< Party Action Report.
        PartyEntitlementsUpdateReport = 10034,            ///< Party Entitlements Update Report.
        PingRequest = 10320,                              ///< Ping Request.
        PingResponse = 10321,                             ///< Ping Response.
        PreTradeRiskLimitResponse = 10313,                ///< Pre Trade Risk Limit Response.
        PreTradeRiskLimitsDefinitionRequest = 10312,      ///< Pre Trade Risk Limits Definition Request.
        QuoteActivationNotification = 10411,              ///< Quote Activation Notification.
        QuoteActivationRequest = 10403,                   ///< Quote Activation Request.
        QuoteActivationResponse = 10404,                  ///< Quote Activation Response.
        QuoteExecutionReport = 10407,                     ///< Quote Execution Report.
        RFQRequest = 10401,                               ///< RFQ Request.
        RFQResponse = 10402,                              ///< RFQ Response.
        Reject = 10010,                                   ///< Reject.
        RetransmitMEMessageRequest = 10026,               ///< Retransmit ME Message Request.
        RetransmitMEMessageResponse = 10027,              ///< Retransmit ME Message Response.
        RetransmitRequest = 10008,                        ///< Retransmit Request.
        RetransmitResponse = 10009,                       ///< Retransmit Response.
        ReverseTESTradeRequest = 10630,                   ///< Reverse TES Trade Request.
        RiskNotificationBroadcast = 10033,                ///< Risk Notification Broadcast.
        SRQSCreateDealNotification = 10708,               ///< SRQS Create Deal Notification.
        SRQSDealNotification = 10709,                     ///< SRQS Deal Notification.
        SRQSDealResponse = 10705,                         ///< SRQS Deal Response.
        SRQSEnterQuoteRequest = 10702,                    ///< SRQS Enter Quote Request.
        SRQSHitQuoteRequest = 10704,                      ///< SRQS Hit Quote Request.
        SRQSInquireSmartRespondentRequest = 10718,        ///< SRQS Inquire Smart Respondent Request.
        SRQSInquireSmartRespondentResponse = 10719,       ///< SRQS Inquire Smart Respondent Response.
        SRQSNegotiationNotification = 10713,              ///< SRQS Negotiation Notification.
        SRQSNegotiationRequesterNotification = 10712,     ///< SRQS Negotiation Requester Notification.
        SRQSNegotiationStatusNotification = 10715,        ///< SRQS Negotiation Status Notification.
        SRQSOpenNegotiationNotification = 10711,          ///< SRQS Open Negotiation Notification.
        SRQSOpenNegotiationRequest = 10700,               ///< SRQS Open Negotiation Request.
        SRQSOpenNegotiationRequesterNotification = 10710, ///< SRQS Open Negotiation Requester Notification.
        SRQSQuoteNotification = 10707,                    ///< SRQS Quote Notification.
        SRQSQuoteResponse = 10703,                        ///< SRQS Quote Response.
        SRQSQuoteSnapshotNotification = 10723,            ///< SRQS Quote Snapshot Notification.
        SRQSQuoteSnapshotRequest = 10720,                 ///< SRQS Quote Snapshot Request.
        SRQSQuotingStatusRequest = 10717,                 ///< SRQS Quoting Status Request.
        SRQSResponse = 10722,                             ///< SRQS Response.
        SRQSStatusBroadcast = 10714,                      ///< SRQS Status Broadcast.
        SRQSUpdateDealStatusRequest = 10706,              ///< SRQS Update Deal Status Request.
        SRQSUpdateNegotiationRequest = 10701,             ///< SRQS Update Negotiation Request.
        ServiceAvailabilityBroadcast = 10030,             ///< Service Availability Broadcast.
        ServiceAvailabilityMarketBroadcast = 10044,       ///< Service Availability Market Broadcast.
        StatusBroadcast = 10045,                          ///< Status Broadcast.
        SubscribeRequest = 10025,                         ///< Subscribe Request.
        SubscribeResponse = 10005,                        ///< Subscribe Response.
        TESApproveBroadcast = 10607,                      ///< TES Approve Broadcast.
        TESBroadcast = 10604,                             ///< TES Broadcast.
        TESDeleteBroadcast = 10606,                       ///< TES Delete Broadcast.
        TESExecutionBroadcast = 10610,                    ///< TES Execution Broadcast.
        TESResponse = 10611,                              ///< TES Response.
        TESReversalBroadcast = 10632,                     ///< TES Reversal Broadcast.
        TESTradeBroadcast = 10614,                        ///< TES Trade Broadcast.
        TESTradingSessionStatusBroadcast = 10615,         ///< TES Trading Session Status Broadcast.
        TESUploadBroadcast = 10613,                       ///< TES Upload Broadcast.
        TMTradingSessionStatusBroadcast = 10501,          ///< TM Trading Session Status Broadcast.
        ThrottleUpdateNotification = 10028,               ///< Throttle Update Notification.
        TradeBroadcast = 10500,                           ///< Trade Broadcast.
        TradingSessionStatusBroadcast = 10307,            ///< Trading Session Status Broadcast.
        UnsubscribeRequest = 10006,                       ///< Unsubscribe Request.
        UnsubscribeResponse = 10007,                      ///< Unsubscribe Response.
        UpdateRemainingRiskAllowanceBaseRequest = 10325,  ///< Update Remaining Risk Allowance Base Request.
        UpdateRemainingRiskAllowanceBaseResponse = 10326, ///< Update Remaining Risk Allowance Base Response.
        UploadTESTradeRequest = 10612,                    ///< Upload TES Trade Request.
        UserLoginRequest = 10018,                         ///< User Login Request.
        UserLoginRequestEncrypted = 19018,                ///< User Login Request Encrypted.
        UserLoginResponse = 10019,                        ///< User Login Response.
        UserLogoutRequest = 10029,                        ///< User Logout Request.
        UserLogoutResponse = 10024,                       ///< User Logout Response.
    };
};

/// Returns string representation.
ONIXS_EUREX_ETI_EXPORT std::string enumToString(TemplateId::Enum);

/// Make it printable using C++ I/O streams.
ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, TemplateId::Enum);

}}} // namespace OnixS::Eurex::Trading