Defines.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 <string>

#include <OnixS/Eurex/MarketData/ABI.h>
#include <OnixS/Eurex/MarketData/Numeric.h>
#include <OnixS/Eurex/MarketData/SequenceNumber.h>
#include <OnixS/Eurex/MarketData/TimeSpan.h>
#include <OnixS/Eurex/MarketData/Timestamp.h>

namespace OnixS
{
    namespace Eurex
    {
        namespace MarketData
        {
            /// Alias for Market Segment type (Product name).
            typedef std::string MarketSegment;

            /// Alias for Market Segment ID type.
            typedef UInt32 MarketSegmentId;

            /// Alias for Market depth type.
            typedef UInt32 MarketDepth;

            const MarketSegmentId UndefinedMarketSegmentId = 0;

            /// Alias for Partition ID type.
            typedef UInt32 PartitionId;

            /// Alias for Security Id type.
            typedef Int64 SecurityId;

            /// Alias for Quantity type.
            typedef UInt64 Quantity;

            /// Feed types based on type of market data service.
            struct NetFeedType
            {
                /// Integral base type of enumeration.
                typedef char Base;

                /// Feed types based on type of market data service.
                enum Enum
                {
                    /// Incremental/real-time.
                    Incremental,

                    /// Market recovery for MBP (Market By Price) books.
                    Snapshot,
                };
            };

            /// Feed roles (primary, secondary).
            struct NetFeedRole
            {
                /// Integral base type of enumeration.
                typedef char Base;

                /// List of known feed roles.
                enum Enum
                {
                    /// Origin is unknown or lost
                    Undefined,

                    /// FeedA
                    FeedA,

                    /// FeedB
                    FeedB
                };
            };

            struct DataSource
            {
                /// Time when the packet was received by Handler from UDP, in system ticks, @see Time.h
                Timestamp packetReceptionTime;

                /// Time when the packet was originally received by Handler from UDP
                /// Valid only for backtesting
                Timestamp originalPacketReceptionTime;

                /// Packet sequence number
                SequenceNumber packetSeqNum;

                /// Packet message number
                SequenceNumber packetMessageSeqNum;

                /// Indicates whether a message is last in the packet
                bool isLastInPacket;

                /// Time when market data feed handler writes packet on the wire.
                UInt64 sendingTime;

                /// Current load of system.
                ///
                /// @note Time difference between the incoming ETS-order/quote
                /// and the time the market data is written to the socket. This
                /// information is provided for the incremental feed of Eurex EMDI only.
                UInt32 performanceIndicator;

                /// Unique id for a sender.
                UInt32 senderCompID;

                /// Sending partition.
                ///
                /// @note For EMDI feed messages only.
                PartitionId partitionId;

                /// Product identifier
                ///
                /// @note For EOBI feed messages only.
                MarketSegmentId marketSegmentId;

                /// An indicator whether the atomic unit of work fits into one datagram
                ///
                /// @note For EOBI feed messages only.
                bool completionIndicator;

                /// An origin of the packet
                typedef NetFeedRole::Enum Origin;
                Origin origin;

                ///
                bool cached;
            };

            /// Exposes list of leg sides
            struct ONIXS_EUREX_EMDI_API LegSide
            {
                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = -1,

                    /// Buy
                    Buy = 1,

                    /// Sell
                    Sell = 2,
                };
            };

            /// Exposes list of available security statuses
            struct ONIXS_EUREX_EMDI_API SecurityStatus
            {
                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = -1,

                    /// Defines if product is traded on on NTA.
                    Active = 0,

                    /// Inactive
                    Inactive = 1,

                    /// Expired
                    Expired = 2,

                    ///
                    KnockedOut = 3,

                    ///
                    KnockOutRevoked = 4,

                    /// Suspended
                    Suspended = 5,

                    /// Defines if product is still traded on "Eurex classic"
                    Published = 6,

                    ///
                    PendingDeletion = 7,

                    ///
                    KnockedOutAndSuspended = 8,

                };
            };

            /// Exposes list of available trade session statuses.
            struct ONIXS_EUREX_EMDI_API TradSesStatus
            {
                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = -1,

                    ///
                    Halted = 0,

                    ///
                    Open = 1,

                    ///
                    Closed = 2,

                    ///
                    PreClose = 3,
                };
            };

            ///
            struct ONIXS_EUREX_EMDI_API ImpliedMarketIndicator
            {
                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = -1,

                    /// Not implied
                    NotImplied = 0,

                    /// Both implied in and implied out
                    BothImpliedInAndImpliedOut = 1,
                };
            };

            /// Exposes list of available entry types
            struct ONIXS_EUREX_EMDI_API MDEntryType
            {
                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = -1,

                    /// Bid
                    Bid = 0,

                    /// Offer
                    Offer = 1,

                    /// Trade
                    Trade = 2,

                    /// Empty book
                    EmptyBook = 3,

                    /// Auction clearing price
                    AuctionClearingPrice = 4,

                    /// Settlement Price
                    SettlementPrice = 5,

                    /// Open Interest
                    OpenInterest = 6,

                    ///Trade Volume
                    TradeVolume = 7,

                    ///Market Bid
                    MarketBid = 8,

                    ///Market Offer
                    MarketOffer = 9,

                    ///Imbalance
                    Imbalance = 10,
                };
            };

            struct ONIXS_EUREX_EMDI_API QuoteCondition
            {
                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = -1,

                    // Crossed,
                    Crossed   = 0,

                    // OrderImbalance,
                    OrderImbalance   = 1,
                };
            };

            /// Exposes list of available trade types
            struct ONIXS_EUREX_EMDI_API TrdType
            {
                // The trade type enum entries do not use numeric values
                // mentioned in documentation. Instead they are identified by
                // ordinal (starting from zero) preserving the order in the doc.

                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = -1,

                    /// Regular Trade
                    RegularTrade = 0,

                    /// Block trade
                    BlockTrade,

                    /// Exchange for Physical
                    EFP,

                    /// Exchange for swap
                    ExchangeForSwap,

                    ///
                    OTC,

                    /// Exchange basis facility
                    ExchangeBasisFacility,

                    /// Vola trade
                    VolaTrade,

                    /// Exchange for Physical Fin trade
                    EFPFinTrade,

                    /// EFPIndexFutures trade
                    EFPIndexFuturesTrade,

                    ///
                    BlockTradeAtMarket,

                    ///
                    XetraEurexEnlightTriggeredTrade,

                    ///
                    BlockQTPIPTrade,

                    ///
                    DeltaTradeAtMarket,

                    /// Opening auction trade
                    OpeningAuctionTrade,

                    /// Intraday auction trade
                    IntradayAuctionTrade,

                    /// Volatility auction trade
                    VolatilityAuctionTrade,

                    /// Closing auction trade
                    ClosingAuctionTrade,

                    /// Cross auction trade
                    CrossAuctionTrade,

                    ///
                    IPOAuctionTrade,

                    ///
                    LiquidityImprovementCross,

                    /// 
                    RetailAuctionTrade,
                };

                static std::string toString (Enum value);
            };

            /// Exposes list of available trading session IDs
            struct ONIXS_EUREX_EMDI_API TradingSessionId
            {
                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = -1,

                    /// Day
                    Day = 0,

                    /// Morning
                    Morning = 1,

                    /// Evening
                    Evening = 2,

                    /// After-Hours
                    AfterHours = 3,

                    /// Holiday
                    Holiday = 4,
                };
            };

            /// Exposes list of available trading session sub IDs
            struct ONIXS_EUREX_EMDI_API TradingSessionSubID
            {
                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = -1,

                    /// PreTrading
                    PreTrading = 0,

                    /// Continuous
                    Continuous = 1,

                    /// Closing
                    Closing = 2,

                    /// PostTrading
                    PostTrading = 3,

                    /// ScheduledIntradayAuction
                    ScheduledIntradayAuction = 4,

                    /// Quiescent
                    Quiescent = 5,

                    /// AnyAuction
                    AnyAuction = 6,

                    ///OutOfMainSessionTrading
                    OutOfMainSessionTrading = 7,

                    /// ContinuousAuctionIssuer
                    ContinuousAuctionIssuer = 8,

                    /// ContinuousAuctionSpecialist
                    ContinuousAuctionSpecialist
                };
            };

            ///
            struct ONIXS_EUREX_EMDI_API TradingStyle
            {
                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = -1,

                    ///
                    Regular = 0,

                    ///
                    TRF_TAC = 1,

                    //
                    TRF_TAM = 2,

                    ///
                    MOC = 3
                };
            };

            /// Exposes list of available security trading statuses
            struct ONIXS_EUREX_EMDI_API SecurityTradingStatus
            {
                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = -1,

                    /// Trading Halt
                    TradingHalt = 0,

                    /// Closed
                    Closed = 1,

                    /// Restricted
                    Restricted = 2,

                    /// Book
                    Book = 3,

                    /// Continuous
                    Continuous = 4,

                    /// Opening auction
                    OpeningAuction = 5,

                    /// Opening auction freeze
                    OpeningAuctionFreeze = 6,

                    /// Intraday auction
                    IntradayAuction = 7,

                    /// Intraday auction freeze
                    IntradayAuctionFreeze = 8,

                    /// Circuit breaker auction
                    CircuitBreakerAuction = 9,

                    /// Circuit breaker auction freeze
                    CircuitBreakerAuctionFreeze = 10,

                    /// Closing auction
                    ClosingAuction = 11,

                    /// Closing auction freeze
                    ClosingAuctionFreeze = 12,

                    /// CIPO Auction
                    IPOAuction = 13,

                    /// IPO Auction Freeze
                    IPOAuctionFreeze = 14,

                    ///
                    PreCall,

                    ///
                    Call,

                    ///
                    Freeze,

                    ///
                    TradeAtClose,

                    ///
                    RetailPreCall,

                    ///
                    RetailCall,

                    ///
                    CircuitBreakerAuctionTriggeredByStaticLimitBreach,

                    ///
                    CircuitBreakerAuctionTriggeredByStaticLimitBreachFreeze
                };
            };

            ///
            struct ONIXS_EUREX_EMDI_API SecurityTradingEvent
            {
                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = -1,

                    ///
                    None = 0,

                    ///
                    PriceVolatilityAuctionIsExtended = 1,

                    ///
                    PriceVolatilityAuctionIsExtendedAgain = 2,
                };
            };

            /// Exposes list of available trade conditions
            struct ONIXS_EUREX_EMDI_API TradeCondition
            {
                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = 0,

                    /// Exchange last
                    ExchangeLast = 1,

                    /// Opening price
                    OpeningPrice = 2,

                    /// High price
                    HighPrice = 4,

                    /// Low price
                    LowPrice = 8,

                    /// Official closing price
                    OfficialClosingPrice = 16,

                    /// Last auction price
                    LastAuctionPrice = 32,

                    /// Out of sequence ETH
                    OutOfSequenceETH = 64,

                    /// Previous Closing Price
                    PreviousClosingPrice = 128,

                    /// Volume Only
                    VolumeOnly = 256,

                    ///
                    TradingOnTermsOfIssue = 512,

                    ///
                    SpecialAuction = 1024,

                    ///
                    TradeAtClose = 2048,

                    ///
                    Retail = 4096,

                    ///
                    MidpointPrice = 8192
                };
            };

            ///
            struct ONIXS_EUREX_EMDI_API MidpointTrading
            {
                enum Enum
                {
                    ///
                    Disabled = 0,

                    ///
                    Enabled = 1,

                    /// Used to identify absence of value.
                    Undefined = -1,
                };
            };

            ///
            struct ONIXS_EUREX_EMDI_API SecurityClassificationReasonType
            {
                enum Enum
                {
                    ///
                    Fee = 0,

                    ///
                    CreditControls = 1,

                    ///
                    Margin = 2,

                    ///
                    EntitlementOrEligibility = 3,

                    ///
                    MarketData = 4,

                    ///
                    AccountSelection = 5,

                    ///
                    DeliveryProcess = 6,

                    ///
                    Sector = 7,

                    /// Used to identify absence of value.
                    Undefined = -1,
                };
            };


            ///
            struct ONIXS_EUREX_EMDI_API SecurityClassificationValueType
            {
                enum Enum
                {
                    ///
                    EligibleForAllTradingActivities = 1,

                    ///
                    NotEligibleForOTCTradeUpload = 2,

                    ///
                    EligibleOnlyForOTCTradeUpload = 3,

                    /// Used to identify absence of value.
                    Undefined = -1,
                };
            };


            struct ONIXS_EUREX_EMDI_API TradeConditionSet
            {
                explicit
                TradeConditionSet (UInt64 value)
                    : value_ (value)
                {}

                bool contain (TradeCondition::Enum value) const
                {
                    return (value_ & value) != 0;
                }

                bool containExchangeLast() const
                {
                    return contain (TradeCondition::ExchangeLast);
                }
                bool containOpeningPrice() const
                {
                    return contain (TradeCondition::OpeningPrice);
                }
                bool containHighPrice() const
                {
                    return contain (TradeCondition::HighPrice);
                }
                bool containLowPrice() const
                {
                    return contain (TradeCondition::LowPrice);
                }
                bool containOfficialClosingPrice() const
                {
                    return contain (TradeCondition::OfficialClosingPrice);
                }
                bool containLastAuctionPrice() const
                {
                    return contain (TradeCondition::LastAuctionPrice);
                }
                bool containOutOfSequenceETH() const
                {
                    return contain (TradeCondition::OutOfSequenceETH);
                }
                bool containPreviousClosingPrice() const
                {
                    return contain (TradeCondition::PreviousClosingPrice);
                }
                bool containVolumeOnly() const
                {
                    return contain (TradeCondition::VolumeOnly);
                }
                bool containRetail() const
                {
                    return contain (TradeCondition::Retail);
                }
                bool containTradingOnTermsOfIssue() const
                {
                    return contain(TradeCondition::TradingOnTermsOfIssue);
                }
                bool containSpecialAuction() const
                {
                    return contain (TradeCondition::SpecialAuction);
                }
                bool containTradeAtClose() const
                {
                    return contain(TradeCondition::TradeAtClose);
                }
                bool containMidpointPrice() const
                {
                    return contain(TradeCondition::MidpointPrice);
                }

                std::string toString() const;

            private:
                UInt64 value_;
            };

            /// Exposes list of available origin types
            struct ONIXS_EUREX_EMDI_API MDOriginType
            {
                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = -1,

                    ///
                    Book = 0,

                    ///
                    OffBook = 1,
                };
            };

            /// Exposes list of available update actions
            struct ONIXS_EUREX_EMDI_API MDUpdateAction
            {
                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = -1,

                    /// New
                    New = 0,

                    /// Change
                    Change = 1,

                    /// Delete
                    Delete = 2,

                    /// DeleteThru
                    DeleteThru = 3,

                    /// DeleteFrom
                    DeleteFrom = 4,

                    /// Overlay
                    Overlay = 5
                };
            };

            /// Exposes list of available aggressor sides
            struct ONIXS_EUREX_EMDI_API Side
            {
                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = -1,

                    /// Buy
                    Buy = 1,

                    /// Sell
                    Sell = 2,
                };
            };

            /// Exposes list of available market segment statuses.
            struct ONIXS_EUREX_EMDI_API MarketSegmentStatus
            {
                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = -1,

                    /// Defines if product is traded on on NTA.
                    Active = 0,

                    /// Inactive
                    Inactive = 1,

                     /// Defines if product is still traded on "Eurex classic"
                    Published = 2,
                };
            };

            /// Exposes list of available instrument types for tick rule.
            struct ONIXS_EUREX_EMDI_API InstrumentType
            {
                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = -1,

                    /// Simple instrument
                    SimpleInstrument = 1,

                    /// Standard option strategy
                    StandardOptionStrategy = 2,

                    /// Non standard option strategy
                    NonStandardOptionStrategy = 3,

                    /// Volatility strategy
                    VolatilityStrategy = 4,

                    /// Futures spread
                    FuturesSpread = 5,

                    /// Inter Product Spread
                    InterProductSpread = 6,

                    /// Standard Futures Strategy
                    StandardFuturesStrategy = 7,

                    /// Pack And Bundle
                    PackAndBundle = 8,

                    /// Strip
                    Strip = 9,

                    /// Flexible
                    Flexible = 10,

                    /// Commodity Strips
                    CommodityStrips = 11,

                    /// Scaled Simple Instrument
                    ScaledSimpleInstrument = 12,

                    /// Non Standard Volatility Strategy
                    NonStandardVolatilityStrategy = 13,

                    /// Total Return Future Strategy
                    TotalReturnFutureStrategy = 14
                };
            };

            /// Exposes list of available book types.
            struct ONIXS_EUREX_EMDI_API BookType
            {
                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = -1,

                    /// Top Of Book
                    TopOfBook = 0,

                    /// Price Depth
                    PriceDepth = 1,

                    /// Order Depth
                    OrderDepth = 2,
                };
            };

            /// Exposes list of available sub book types.
            struct ONIXS_EUREX_EMDI_API SubBookType
            {
                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = -1,

                    /// Price Depth
                    IPSImpliedVolumeWithoutQuantityRestriction = 0,

                    /// Order Depth
                    IPSImpliedVolumeWithQuantityRestriction = 1,
                };
            };

            /// Indicator for stressed market conditions.
            struct ONIXS_EUREX_EMDI_API MarketCondition
            {
                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = -1,

                    /// Normal
                    Normal = 0,

                    /// Stressed
                    Stressed = 1
                };
            };

            /// A trade has to be flagged as "algorithmic", if at least one of the
            /// matched orders was submitted by a trading algorithm.Applicable
            /// for cash market products only.
            struct ONIXS_EUREX_EMDI_API AlgorithmicTradeIndicator
            {
                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = -1,

                    /// Algorithmic Trade
                    AlgorithmicTrade = 1
                };
            };

            /// MultiLegReportingType
            struct ONIXS_EUREX_EMDI_API MultiLegReportingType
            {
                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = -1,

                    /// Single Security
                    SingleSecurity = 1,

                    /// Individual Leg Of A MultiLeg Security
                    IndividualLegOfMultiLegSecurity = 2,

                    /// Multi Leg Security
                    MultiLegSecurity = 3
                };
            };

            /// MultiLegPriceModel
            struct ONIXS_EUREX_EMDI_API MultiLegPriceModel
            {
                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = -1,

                    /// Standard
                    Standard = 0,

                    /// User Defined
                    UserDefined = 2
                };
            };


            /// Exposes list of available sold out indicators.
            struct ONIXS_EUREX_EMDI_API SoldOutIndicator
            {
                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = -1,

                    ///
                    SoldOut = 1,
                };
            };

            ///
            struct ONIXS_EUREX_EMDI_API LastFragment
            {
                enum Enum
                {
                    /// Used to identify absence of value.
                    Undefined = -1,

                    /// NotLastMessage
                    NotLastMessage = 0,

                    /// LastMessage
                    LastMessage,
                };
            };

            namespace EOBI
            {
                /// Alias for Quantity Type
                /// Quantity in integer format including 4 decimals.
                typedef Int64 QuantityType;

                struct ONIXS_EUREX_EMDI_API AggressorSide // UInt8
                {
                    enum Enum
                    {
                        /// Used to identify absence of value
                        NoValue = 0xFF,

                        /// Triggered by the buy side
                        Buy = 1,

                        /// Triggered by the sell side
                        Sell = 2,
                    };

                    static std::string toString (Enum value);
                };

                struct ONIXS_EUREX_EMDI_API ApplSeqResetIndicator // UInt8
                {
                    enum Enum
                    {
                        NoValue = 0xFF,
                        NoReset = 0,
                        Reset   = 1,
                    };

                    static std::string toString (Enum value);
                };

                struct ONIXS_EUREX_EMDI_API CompletionIndicator // UInt8
                {
                    enum Enum
                    {
                        NoValue     = 0xFF,
                        Incomplete  = 0,
                        Complete    = 1,
                    };

                    static std::string toString (Enum value);
                };

                struct ONIXS_EUREX_EMDI_API FastMarketIndicator // UInt8
                {
                    enum Enum
                    {
                        NoValue = 0xFF,
                        No      = 0,
                        Yes     = 1,
                    };

                    static std::string toString (Enum value);
                };

                struct ONIXS_EUREX_EMDI_API ImpliedMarketIndicator // UInt8
                {
                    enum Enum
                    {
                        NoValue      = 0xFF,
                        NotImplied   = 0,
                        ImpliedInOut = 3,
                    };

                    static std::string toString (Enum value);
                };

                struct ONIXS_EUREX_EMDI_API LegSecurityIDSource // String(1)
                {
                    enum Enum
                    {
                        NoValue     = 0,
                        Marketplace = 'M',
                    };

                    static std::string toString (Enum value);
                };

                struct ONIXS_EUREX_EMDI_API LegSide // UInt8
                {
                    enum Enum
                    {
                        NoValue = 0xFF,
                        Buy     = 1,
                        Sell    = 2,
                    };

                    static std::string toString (Enum value);
                };

                struct ONIXS_EUREX_EMDI_API RelatedPriceType // uint8_t
                {
                    enum Enum
                    {
                        NoValue = 0xFF,
                        Basis = 1,
                        CustomUnderlyingPrice = 2
                    };

                    static std::string toString (Enum value);
                };

                struct ONIXS_EUREX_EMDI_API TradingStyle // uint8_t
                {
                    enum Enum
                    {
                        NoValue = 0xFF,
                        Regular = 1,
                        TAC = 2,
                        TAM = 3,
                        MOC = 4,
                    };

                    static std::string toString (Enum value);
                };

                
                struct ONIXS_EUREX_EMDI_API MDEntryType // UInt8
                {
                    enum Enum
                    {
                        NoValue                 = 0xFF,
                        Trade                   = 2,
                        OpeningPrice            = 4,
                        ClosingPrice            = 5,
                        HighPrice               = 7,
                        LowPrice                = 8,
                        TradeVolume             = 66,
                        PreviousClosingPrice    = 101,
                        OpeningAuction          = 200,
                        IntradayAuction         = 201,
                        CircuitBreakerAuction   = 202,
                        ClosingAuction          = 203,
                        IPOAuction              = 204,
                        RetailAuction           = 205,
                    };

                    static std::string toString (Enum value);
                };

                struct ONIXS_EUREX_EMDI_API MDReportEvent // UInt8
                {
                    enum Enum
                    {
                        NoValue         = 0xFF,
                        ScopeDefinition = 0,
                    };
                };

                struct ONIXS_EUREX_EMDI_API MDUpdateAction // UInt8
                {
                    enum Enum
                    {
                        NoValue = 0xFF,
                        New     = 0,
                        Change  = 1,
                        Delete  = 2,
                        Overlay = 5,
                    };
                };

                struct ONIXS_EUREX_EMDI_API MarketDataType // UInt8
                {
                    enum Enum
                    {
                        NoValue                     = 0xFF,
                        OrderBookMaintenance        = 1,
                        OrderBookExecution          = 2,
                        TradeReversal               = 3,
                        TradeReport                 = 4,
                        AuctionBBO                  = 5,
                        AuctionClearingPrice        = 6,
                        CrossTradeAnnouncement      = 7,
                        QuoteRequest                = 8,
                        MarketSegmentSnapshot       = 9,
                        SingleInstrumentSnapshot    = 10,
                        OrderBookSnapshot           = 11,
                        MatchEvent                  = 12,
                        TopOfBook                   = 13,

                        ComplexInstrument           = 14,
                        TesTradeReport              = 15,
                        HhIndex                     = 16,
                        FlexibleInstrument          = 17,
                    };
                };

                struct ONIXS_EUREX_EMDI_API MatchSubType // UInt8
                {
                    enum Enum
                    {
                        NoValue                 = 0xFF,
                        OpeningAuction          = 1,
                        ClosingAuction          = 2,
                        IntradayAuction         = 3,
                        CircuitBreakerAuction   = 4,
                        IPOAuction              = 5,
                        RetailAuctionVolaTrade  = 6,
                    };

                    static std::string toString (Enum value);
                };

                struct ONIXS_EUREX_EMDI_API MatchType // UInt8
                {
                    enum Enum
                    {
                        NoValue                   = 0xFF,
                        Manual                    = 3,
                        Uncrossing                = 5,
                        Auction                   = 7,
                        LiquidityImprovementCross = 13,
                        ContinuousAuction         = 14
                    };

                    static std::string toString (Enum value);
                };

                struct ONIXS_EUREX_EMDI_API NoMarketSegments // UInt8
                {
                    enum Enum
                    {
                        NoValue = 0xFF,
                        One     = 1,
                    };

                    static std::string toString (Enum value);
                };

                struct ONIXS_EUREX_EMDI_API ProductComplex // UInt8
                {
                    enum Enum
                    {
                        NoValue         = 0xFF,

                        SimpleInstrument = 1,
                        StandardOptionStrategy = 2,
                        NonStandardOptionStrategy = 3,
                        VolatilityStrategy = 4,
                        FuturesSpread   = 5,
                        InterProductSpread = 6,
                        StandardFuturesStrategy = 7,
                        PackAndBundle = 8,
                        Strip = 9,
                        FlexibleInstrument = 10,
                        CommodityStrip = 11,
                        ScaledSimpleInstrument = 12,
                        NonStandardVolatilityStrategy = 13,
                        TotalReturnFutureStrategy = 14
                    };

                    static std::string toString (Enum value);
                };

                struct ONIXS_EUREX_EMDI_API SecurityIDSource // String(1)
                {
                    enum Enum
                    {
                        NoValue     = 0,
                        Marketplace = 'M',
                    };

                    static std::string toString (Enum value);
                };

                struct ONIXS_EUREX_EMDI_API SecurityStatus // UInt8
                {
                    enum Enum
                    {
                        NoValue     = 0xFF,
                        Active      = 1,
                        Inactive    = 2,
                        Expired     = 4,
                        KnockedOut  = 6,
                        KnockOutRevoked = 7,
                        Suspended   = 9,
                        PendingDeletion = 11,
                        KnockedOutAndSuspended = 12,
                    };

                    static std::string toString (Enum value);
                };

                struct ONIXS_EUREX_EMDI_API SecurityTradingStatus // UInt8
                {
                    enum Enum
                    {
                        NoValue                     = 0xFF,

                        TradingHalt                 = 2,
                        MarketImbalanceBuy          = 7,
                        MarketImbalanceSell         = 8,
                        Closed                      = 200,
                        Restricted                  = 201,
                        Book                        = 202,
                        Continuous                  = 203,
                        OpeningAuction              = 204,
                        OpeningAuctionFreeze        = 205,
                        IntradayAuction             = 206,
                        IntradayAuctionFreeze       = 207,
                        CircuitBreakerAuction       = 208,
                        CircuitBreakerAuctionFreeze = 209,
                        ClosingAuction              = 210,
                        ClosingAuctionFreeze        = 211,
                        IPOAuction                  = 212,
                        IPOAuctionFreeze            = 213,
                        PreCall                     = 214,
                        Call                        = 215,
                        Freeze                      = 216,
                        TradeAtClose                = 217,
                        RetailPreCall = 218,
                        RetailCall = 219,
                        CircuitBreakerAuctionTriggeredByStaticLimitBreach = 220,
                        CircuitBreakerAuctionTriggeredByStaticLimitBreachFreeze = 221,
                    };

                    static std::string toString (Enum value);
                };

                struct ONIXS_EUREX_EMDI_API SecurityType // String(4)
                {
                    enum Enum
                    {
                        NoValue  = 0,
                        Option   = 1, // OPT,
                        Future   = 2, // FUT,
                        MultiLeg = 3  // MLEG,
                    };

                    static std::string toString (Enum value);
                };

                struct ONIXS_EUREX_EMDI_API SecurityUpdateAction // String(1)
                {
                    enum Enum
                    {
                        NoValue = 0,
                        Add     = 'A',
                        Delete  = 'D',
                    };

                    static std::string toString (Enum value);
                };

                struct ONIXS_EUREX_EMDI_API Side // UInt8
                {
                    enum Enum
                    {
                        NoValue = 0xFF,
                        Buy     = 1,
                        Sell    = 2,
                    };

                    static std::string toString (Enum value);
                };

                struct ONIXS_EUREX_EMDI_API CrossRequestType // UInt8
                {
                    enum Enum
                    {
                        Undefined = 0xFF,
                        CrossAnnouncement = 1,
                        LiquidityImprovementCross = 2,
                    };

                    static std::string toString (Enum value);
                };

                struct ONIXS_EUREX_EMDI_API InputSource // UInt8
                {
                    enum Enum
                    {
                        Undefined = 0xFF,
                        ClipClientBroker = 1,
                    };

                    static std::string toString (Enum value);
                };

                /// Indicates whether a synthetic match is occurred.
                struct ONIXS_EUREX_EMDI_API TradeCondition // UInt16
                {
                    enum Enum
                    {
                        NoValue      = 0xFFFF,
                        ImpliedTrade = 1,
                        OutOfSequence = 107,
                        MidpointPrice = 155,
                        TradingOnTermsOfIssue = 156,
                        SpetialAuction = 596,
                        TradeAtClose = 624,
                        Retail = 743
                    };

                    static std::string toString (Enum value);
                };

                struct ONIXS_EUREX_EMDI_API TradSesEvent // UInt8
                {
                    enum Enum
                    {
                        NoValue         = 0xFF,
                        TBD             = 0,
                        StatusChange    = 3,
                    };

                    static std::string toString (Enum value);
                };

                struct ONIXS_EUREX_EMDI_API TradSesStatus // UInt8
                {
                    enum Enum
                    {
                        NoValue = 0xFF,
                        Halted  = 1,
                        Open    = 2,
                        Closed  = 3,
                    };

                    static std::string toString (Enum value);
                };

                struct ONIXS_EUREX_EMDI_API TradingSessionID // UInt8
                {
                    enum Enum
                    {
                        NoValue = 0xFF,
                        Day     = 1,
                        Morning = 3,
                        Evening = 5,
                        AfterHours = 6,
                        Holiday = 7,
                    };

                    static std::string toString (Enum value);
                };

                struct ONIXS_EUREX_EMDI_API TradingSessionSubID // UInt8
                {
                    enum Enum
                    {
                        NoValue     = 0xFF,
                        PreTrading  = 1,
                        Continuous = 3,
                        Closing     = 4,
                        PostTrading = 5,
                        Quiescent   = 7,
                        OutOfMainSessionTrading = 10
                    };

                    static std::string toString (Enum value);
                };


                struct ONIXS_EUREX_EMDI_API PotentialSecurityTradingEvent // UInt8
                {
                    enum Enum
                    {
                        NoValue     = 0xFF,

                        /// None
                        None  = 0,

                        /// Price volatility, auction is extended
                        PriceVolatilityAuctionIsExtended = 10,
                    };

                    static std::string toString (Enum value);
                };

                struct ONIXS_EUREX_EMDI_API OrdType // UInt8
                {
                    enum Enum
                    {
                        NoValue = 0xFF,

                        /// Market Order
                        MarketOrder = 1,
                    };

                    static std::string toString(Enum value);
                };

                struct ONIXS_EUREX_EMDI_API SecurityTradingEvent // UInt8
                {
                    enum Enum
                    {
                        NoValue     = 0xFF,

                        /// Price volatility, auction is extended
                        PriceVolatilityAuctionIsExtended = 10,

                        /// Price volatility, auction is extended again
                        PriceVolatilityAuctionIsExtendedAgain = 11,
                    };

                    static std::string toString (Enum value);
                };

                struct ONIXS_EUREX_EMDI_API OrderType // UInt8
                {
                    enum Enum
                    {
                        NoValue     = 0xFF,

                        ///
                        MarketOrder = 1,
                    };

                    static std::string toString (Enum value);
                };

                struct ONIXS_EUREX_EMDI_API AlgorithmicTradeIndicator // UInt8
                {
                    enum Enum
                    {
                        NoValue = 0xFF,

                        ///
                        AlgorithmicTrade = 1,
                    };

                    static std::string toString(Enum value);
                };

                struct ONIXS_EUREX_EMDI_API MarketCondition // UInt8
                {
                    enum Enum
                    {
                        NoValue = 0xFF,

                        ///
                        Normal = 0,

                        ///
                        Stressed = 1
                    };

                    static std::string toString(Enum value);
                };

                struct ONIXS_EUREX_EMDI_API LegSecurityType // UInt8
                {
                    enum Enum
                    {
                        NoValue = 0xFF,

                        ///
                        LegSecurityMultiLeg = 0,

                        ///
                        LegSecurityUnderlyingLeg = 1
                    };

                    static std::string toString(Enum value);
                };

                struct ONIXS_EUREX_EMDI_API SoldOutIndicator // UInt8
                {
                    enum Enum
                    {
                        NoValue = 0xFF,

                        ///
                        SoldOut = 1,
                    };

                    static std::string toString(Enum value);
                };

                struct ONIXS_EUREX_EMDI_API SecurityMassStatus // UInt8
                {
                    enum Enum
                    {
                        NoValue = 0xFF,

                        ///
                        Active = 1,

                        ///
                        Inactive = 2,

                        ///
                        Expired = 4,

                        ///
                        KnockedOut = 6,

                        ///
                        KnockOutRevoked = 7,

                        ///
                        Suspended = 9,

                        ///
                        PendingDeletion = 11,

                        ///
                        KnockedOutAndSuspended = 12
                    };

                    static std::string toString(Enum value);
                };

                struct ONIXS_EUREX_EMDI_API SecurityMassTradingStatus // UInt8
                {
                    enum Enum
                    {
                        NoValue = 0xFF,

                        ///
                        TradingHalt = 2,

                        ///
                        MarketImbalanceBuy = 7,

                        ///
                        MarketImbalanceSell = 8,

                        ///
                        Closed = 200,

                        ///
                        Restricted = 201,

                        ///
                        Book = 202,

                        ///
                        Continuous = 203,

                        ///
                        OpeningAuction = 204,

                        ///
                        OpeningAuctionFreeze = 205,

                        ///
                        IntradayAuction = 206,

                        ///
                        IntradayAuctionFreeze = 207,

                        ///
                        CircuitBreakerAuction = 208,

                        ///
                        CircuitBreakerAuctionFreeze = 209,

                        ///
                        ClosingAuction = 210,

                        ///
                        ClosingAuctionFreeze = 211,

                        ///
                        IPOAuction = 212,

                        ///
                        IPOAuctionFreeze = 213,

                        ///
                        PreCall = 214,

                        ///
                        Call = 215,

                        ///
                        Freeze = 216,

                        ///
                        TradeAtClose = 217,

                        ///
                        RetailPreCall = 218,

                        ///
                        RetailCall = 219,

                        ///
                        CircuitBreakerAuctionTriggeredByStaticLimitBreach = 220,

                        ///
                        CircuitBreakerAuctionTriggeredByStaticLimitBreachFreeze = 221,

                    };

                    static std::string toString(Enum value);
                };

                struct ONIXS_EUREX_EMDI_API MassMarketCondition // UInt8
                {
                    enum Enum
                    {
                        NoValue = 0xFF,

                        ///
                        Normal = 0,

                        ///
                        Stressed = 1
                    };

                    static std::string toString(Enum value);
                };

                struct ONIXS_EUREX_EMDI_API SecurityMassTradingEvent // UInt8
                {
                    enum Enum
                    {
                        NoValue = 0xFF,

                        /// Price volatility, auction is extended
                        PriceVolatilityAuctionIsExtended = 10,

                        /// Price volatility, auction is extended again
                        PriceVolatilityAuctionIsExtendedAgain = 11
                    };

                    static std::string toString(Enum value);
                };

                struct ONIXS_EUREX_EMDI_API MassSoldOutIndicator // UInt8
                {
                    enum Enum
                    {
                        NoValue = 0xFF,

                        ///
                        SoldOut = 1,
                    };

                    static std::string toString(Enum value);
                };


                struct ONIXS_EUREX_EMDI_API LastFragment // UInt8
                {
                    enum Enum
                    {
                        NoValue = 0xFF,

                        ///
                        N = 0,

                        ///
                        Y = 1,
                    };

                    static std::string toString(Enum value);
                };

                struct ONIXS_EUREX_EMDI_API PutOrCall // UInt8
                {
                    enum Enum
                    {
                        NoValue = 0xFF,

                        ///
                        Put = 0,

                        ///
                        Call = 1,
                    };

                    static std::string toString(Enum value);
                };

                struct ONIXS_EUREX_EMDI_API ExerciseStyle // UInt8
                {
                    enum Enum
                    {
                        NoValue = 0xFF,

                        ///
                        European = 0,

                        ///
                        American = 1,
                    };

                    static std::string toString(Enum value);
                };

                struct ONIXS_EUREX_EMDI_API SettlMethod // UInt8
                {
                    enum Enum
                    {
                        NoValue = 0xFF,

                        ///
                        Cash = 0,

                        ///
                        Physical = 1,
                    };

                    static std::string toString(Enum value);
                };


                struct ONIXS_EUREX_EMDI_API TrdType // UInt16
                {
                    enum Enum
                    {
                        NoValue = 0xFFFF,

                        BlockTrade = 1,
                        ExchangeForPhysical = 2,
                        EFS = 12,
                        PortfolioCompressionTrade = 50,
                        OTC = 54,
                        ExchangeBasisFacility = 55,
                        VolaTrade = 1000,
                        EFPFinTrade = 1001,
                        EFPIndexFuturesTrade = 1002,
                        BlockTradeAtMarket = 1004,
                        XetraEurexEnlightTriggeredTrade = 1006,
                        BlockQTPIPTrade = 1007,
                        TradeAtMarket = 1017
                    };

                    static std::string toString(Enum value);
                };

                struct ONIXS_EUREX_EMDI_API MultiLegReportingType // UInt8
                {
                    enum Enum
                    {
                        NoValue = 0xFF,

                        ///
                        SingleSecurity = 1,

                        ///
                        IndividualLeg = 2,

                        ///
                        MultiLegSecurity = 3,
                    };

                    static std::string toString(Enum value);
                };

                struct ONIXS_EUREX_EMDI_API MultiLegPriceModel // UInt8
                {
                    enum Enum
                    {
                        NoValue = 0xFF,

                        ///
                        Standard = 0,

                        ///
                        UserDefined = 1,
                    };

                    static std::string toString(Enum value);
                };

                struct ONIXS_EUREX_EMDI_API MDOriginType // UInt8
                {
                    enum Enum
                    {
                        NoValue = 0xFF,

                        ///
                        Book = 0,

                        ///
                        OffBook = 1,
                    };

                    static std::string toString(Enum value);
                };

                struct ONIXS_EUREX_EMDI_API TESTradSesStatus // UInt8
                {
                    enum Enum
                    {
                        NoValue = 0xFF,

                        ///
                        Halted = 1,

                        ///
                        Open = 2,

                        ///
                        Closed = 3,

                        ///
                        PreClose = 4,
                    };

                    static std::string toString(Enum value);
                };


                struct ONIXS_EUREX_EMDI_API TESSecurityStatus // UInt8
                {
                    enum Enum
                    {
                        NoValue = 0xFF,

                        ///
                        Active = 1,

                        ///
                        Inactive = 2,

                        ///
                        Expired = 4,

                        ///
                        Suspended = 9,
                    };

                    static std::string toString(Enum value);
                };

                struct ONIXS_EUREX_EMDI_API TESSecurityMassStatus // UInt8
                {
                    enum Enum
                    {
                        NoValue = 0xFF,

                        ///
                        Active = 1,

                        ///
                        Inactive = 2,

                        ///
                        Expired = 4,

                        ///
                        Suspended = 9,
                    };

                    static std::string toString(Enum value);
                };

            }
        }
    }
}