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 {

struct ONIXS_EUREX_ETI_EXPORT ApplId
{
    enum Enum
    {
        NoValue = 0xFF,                
        Trade = 1,                     
        News = 2,                      
        ServiceAvailability = 3,       
        SessionData = 4,               
        ListenerData = 5,              
        RiskControl = 6,               
        TESMaintenance = 7,            
        TESTrade = 8,                  
        SRQSMaintenance = 9,           
        ServiceAvailabilityMarket = 10 
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(ApplId::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, ApplId::Enum);

struct ONIXS_EUREX_ETI_EXPORT ApplIdStatus
{
    enum Enum
    {
        NoValue = 0xFF,               
        OutboundConversionError = 105 
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(ApplIdStatus::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, ApplIdStatus::Enum);

struct ONIXS_EUREX_ETI_EXPORT ApplResendFlag
{
    enum Enum
    {
        NoValue = 0xFF, 
        False = 0,      
        True = 1        
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(ApplResendFlag::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, ApplResendFlag::Enum);

struct ONIXS_EUREX_ETI_EXPORT ApplSeqIndicator
{
    enum Enum
    {
        NoValue = 0xFF,         
        NoRecoveryRequired = 0, 
        RecoveryRequired = 1    
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(ApplSeqIndicator::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, ApplSeqIndicator::Enum);

struct ONIXS_EUREX_ETI_EXPORT ApplSeqStatus
{
    enum Enum
    {
        NoValue = 0xFF,  
        Unavailable = 0, 
        Available = 1    
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(ApplSeqStatus::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, ApplSeqStatus::Enum);

struct ONIXS_EUREX_ETI_EXPORT BasketAnonymity
{
    enum Enum
    {
        NoValue = 0xFF, 
        No = 0,         
        Yes = 1         
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(BasketAnonymity::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, BasketAnonymity::Enum);

struct ONIXS_EUREX_ETI_EXPORT BasketTradeReportType
{
    enum Enum
    {
        NoValue = 0xFF,     
        Submit = 0,         
        Addendum = 4,       
        NoWasSubstitue = 5, 
        Terminate = 19      
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(BasketTradeReportType::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, BasketTradeReportType::Enum);

struct ONIXS_EUREX_ETI_EXPORT BidPxIsLocked
{
    enum Enum
    {
        NoValue = 0xFF, 
        No = 0,         
        Yes = 1         
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(BidPxIsLocked::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, BidPxIsLocked::Enum);

struct ONIXS_EUREX_ETI_EXPORT ChargeIdDisclosureInstruction
{
    enum Enum
    {
        NoValue = 0xFF, 
        No = 0,         
        Yes = 1         
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(ChargeIdDisclosureInstruction::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, ChargeIdDisclosureInstruction::Enum);

struct ONIXS_EUREX_ETI_EXPORT CrossMatchInstruction
{
    enum Enum
    {
        NoValue = 0xFF,                
        CancelAggressive = 1,          
        CancelPassive = 2,             
        CancelAggressiveAndPassive = 3 
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(CrossMatchInstruction::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, CrossMatchInstruction::Enum);

struct ONIXS_EUREX_ETI_EXPORT CrossPrioritization
{
    enum Enum
    {
        NoValue = 0xFF, 
        BuySide = 1,    
        SellSide = 2    
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(CrossPrioritization::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, CrossPrioritization::Enum);

struct ONIXS_EUREX_ETI_EXPORT CrossRequestType
{
    enum Enum
    {
        NoValue = 0xFF, 
        Cross = 1,      
        Clip = 2        
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(CrossRequestType::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, CrossRequestType::Enum);

struct ONIXS_EUREX_ETI_EXPORT CrossType
{
    enum Enum
    {
        NoValue = 0xFF,  
        CrossIOC = 2,    
        CrossOneSide = 3 
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(CrossType::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, CrossType::Enum);

struct ONIXS_EUREX_ETI_EXPORT CrossedIndicator
{
    enum Enum
    {
        NoValue = 0xFF,   
        NoCrossing = 0,   
        CrossRejected = 1 
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(CrossedIndicator::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, CrossedIndicator::Enum);

struct ONIXS_EUREX_ETI_EXPORT CustOrderHandlingInst
{
    enum Enum
    {
        NoValue = 0x00, 
        W = 'W',        
        Y = 'Y',        
        C = 'C',        
        G = 'G',        
        H = 'H',        
        D = 'D'         
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(CustOrderHandlingInst::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, CustOrderHandlingInst::Enum);

struct ONIXS_EUREX_ETI_EXPORT DeleteReason
{
    enum Enum
    {
        NoValue = 0xFF,               
        NoSpecialReason = 100,        
        TASChange = 101,              
        IntradayExpiration = 102,     
        RiskEvent = 103,              
        StopTrading = 104,            
        InstrumentDeletion = 105,     
        InstrumentSuspension = 106,   
        PreTradeRiskEvent = 107,      
        AmendmentReset = 108,         
        AmendmentUserCancelled = 109, 
        D2OrderCancellation = 112     
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(DeleteReason::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, DeleteReason::Enum);

struct ONIXS_EUREX_ETI_EXPORT EffectOnBasket
{
    enum Enum
    {
        NoValue = 0xFF,  
        AddVolume = 1,   
        RemoveVolume = 2 
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(EffectOnBasket::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, EffectOnBasket::Enum);

struct ONIXS_EUREX_ETI_EXPORT EnableCustomCommodityStrip
{
    enum Enum
    {
        NoValue = 0xFF, 
        Yes = 1         
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(EnableCustomCommodityStrip::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, EnableCustomCommodityStrip::Enum);

struct ONIXS_EUREX_ETI_EXPORT EnlightRFQAvgRespRateRanking
{
    enum Enum
    {
        NoValue = 0xFF, 
        Low = 1,        
        Medium = 2,     
        High = 3        
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(EnlightRFQAvgRespRateRanking::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, EnlightRFQAvgRespRateRanking::Enum);

struct ONIXS_EUREX_ETI_EXPORT EnlightRFQAvgRespTimeRanking
{
    enum Enum
    {
        NoValue = 0xFF, 
        Low = 1,        
        Medium = 2,     
        High = 3        
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(EnlightRFQAvgRespTimeRanking::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, EnlightRFQAvgRespTimeRanking::Enum);

struct ONIXS_EUREX_ETI_EXPORT EurexVolumeRanking
{
    enum Enum
    {
        NoValue = 0xFF, 
        Low = 1,        
        Medium = 2,     
        High = 3        
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(EurexVolumeRanking::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, EurexVolumeRanking::Enum);

struct ONIXS_EUREX_ETI_EXPORT EventType
{
    enum Enum
    {
        NoValue = 0xFF,    
        SwapStartDate = 8, 
        SwapEndDate = 9    
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(EventType::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, EventType::Enum);

struct ONIXS_EUREX_ETI_EXPORT ExecInst
{
    enum Enum
    {
        NoValue = 0xFF, 
        H = 1,          
        Q = 2,          
        HQ = 3,         
        H6 = 5,         
        Q6 = 6          
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(ExecInst::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, ExecInst::Enum);

struct ONIXS_EUREX_ETI_EXPORT ExecRestatementReason
{
    enum Enum
    {
        NoValue = 0xFF,                    
        OrderBookRestatement = 1,          
        OrderAdded = 101,                  
        OrderModified = 102,               
        OrderCancelled = 103,              
        IOCOrderCancelled = 105,           
        FOKOrderCancelled = 107,           
        BookOrderExecuted = 108,           
        ChangedToIOC = 114,                
        MemberDisable = 117,               
        InstrumentStateChange = 122,       
        MarketOrderTriggered = 135,        
        CAOOrderActivated = 149,           
        CAOOrderInactivated = 150,         
        OAOOrderActivated = 151,           
        OAOOrderInactivated = 152,         
        AAOOrderActivated = 153,           
        AAOOrderInactivated = 154,         
        OCOOrderTriggered = 164,           
        StopOrderTriggered = 172,          
        OwnershipChanged = 181,            
        OrderCancellationPending = 197,    
        PendingCancellationExecuted = 199, 
        BOCOrderCancelled = 212,           
        PanicCancel = 261,                 
        MarketOrderUncrossing = 302,       
        CLIPExecution = 340,               
        CLIPArrangementTimeOut = 343,      
        CLIPArrangementValidation = 344,   
        CrossOrderAdded = 346,             
        CrossOrderCancelled = 347          
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(ExecRestatementReason::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, ExecRestatementReason::Enum);

struct ONIXS_EUREX_ETI_EXPORT ExecType
{
    enum Enum
    {
        NoValue = 0x00,       
        New = '0',            
        Canceled = '4',       
        Replaced = '5',       
        PendingCancelE = '6', 
        Suspended = '9',      
        Restated = 'D',       
        Triggered = 'L',      
        Trade = 'F'           
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(ExecType::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, ExecType::Enum);

struct ONIXS_EUREX_ETI_EXPORT ExecutingTraderQualifier
{
    enum Enum
    {
        NoValue = 0xFF, 
        Algo = 22,      
        Human = 24      
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(ExecutingTraderQualifier::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, ExecutingTraderQualifier::Enum);

struct ONIXS_EUREX_ETI_EXPORT ExerciseStyle
{
    enum Enum
    {
        NoValue = 0xFF, 
        European = 0,   
        American = 1    
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(ExerciseStyle::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, ExerciseStyle::Enum);

struct ONIXS_EUREX_ETI_EXPORT FillLiquidityInd
{
    enum Enum
    {
        NoValue = 0xFF,          
        AddedLiquidity = 1,      
        RemovedLiquidity = 2,    
        Auction = 4,             
        TriggeredStopOrder = 5,  
        TriggeredOCOOrder = 6,   
        TriggeredMarketOrder = 7 
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(FillLiquidityInd::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, FillLiquidityInd::Enum);

struct ONIXS_EUREX_ETI_EXPORT FreeText5DisclosureInstruction
{
    enum Enum
    {
        NoValue = 0xFF, 
        No = 0,         
        Yes = 1         
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(FreeText5DisclosureInstruction::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, FreeText5DisclosureInstruction::Enum);

struct ONIXS_EUREX_ETI_EXPORT GatewayStatus
{
    enum Enum
    {
        NoValue = 0xFF, 
        Standby = 0,    
        Active = 1      
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(GatewayStatus::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, GatewayStatus::Enum);

struct ONIXS_EUREX_ETI_EXPORT HedgeType
{
    enum Enum
    {
        NoValue = 0xFF,      
        DurationHedge = 0,   
        NominalHedge = 1,    
        PriceFactorHedge = 2 
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(HedgeType::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, HedgeType::Enum);

struct ONIXS_EUREX_ETI_EXPORT HedgingInstruction
{
    enum Enum
    {
        NoValue = 0xFF, 
        OnClose = 1     
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(HedgingInstruction::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, HedgingInstruction::Enum);

struct ONIXS_EUREX_ETI_EXPORT ImpliedCheckPriceIndicator
{
    enum Enum
    {
        NoValue = 0xFF, 
        No = 0,         
        Yes = 1         
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(ImpliedCheckPriceIndicator::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, ImpliedCheckPriceIndicator::Enum);

struct ONIXS_EUREX_ETI_EXPORT ImpliedMarketIndicator
{
    enum Enum
    {
        NoValue = 0xFF,  
        NotImplied = 0,  
        ImpliedInOut = 3 
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(ImpliedMarketIndicator::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, ImpliedMarketIndicator::Enum);

struct ONIXS_EUREX_ETI_EXPORT InputSource
{
    enum Enum
    {
        NoValue = 0xFF,       
        ClientBroker = 1,     
        ProprietaryBroker = 2 
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(InputSource::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, InputSource::Enum);

struct ONIXS_EUREX_ETI_EXPORT InstrAttribType
{
    enum Enum
    {
        NoValue = 0xFF,                      
        VariableRate = 5,                    
        CouponRate = 100,                    
        OffsetToTheVariableCouponRate = 101, 
        SwapCustomer1 = 102,                 
        SwapCustomer2 = 103,                 
        CashBasketReference = 104            
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(InstrAttribType::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, InstrAttribType::Enum);

struct ONIXS_EUREX_ETI_EXPORT InventoryCheckType
{
    enum Enum
    {
        NoValue = 0xFF, 
        DoNotCheck = 0, 
        Check = 1       
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(InventoryCheckType::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, InventoryCheckType::Enum);

struct ONIXS_EUREX_ETI_EXPORT LastFragment
{
    enum Enum
    {
        NoValue = 0xFF,     
        NotLastMessage = 0, 
        LastMessage = 1     
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(LastFragment::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, LastFragment::Enum);

struct ONIXS_EUREX_ETI_EXPORT LastMkt
{
    enum Enum
    {
        NoValue = 0xFF, 
        XEUR = 1,       
        XEEE = 2,       
        NODX = 12       
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(LastMkt::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, LastMkt::Enum);

struct ONIXS_EUREX_ETI_EXPORT LastPxDisclosureInstruction
{
    enum Enum
    {
        NoValue = 0xFF, 
        No = 0,         
        Yes = 1         
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(LastPxDisclosureInstruction::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, LastPxDisclosureInstruction::Enum);

struct ONIXS_EUREX_ETI_EXPORT LastQtyDisclosureInstruction
{
    enum Enum
    {
        NoValue = 0xFF, 
        No = 0,         
        Yes = 1         
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(LastQtyDisclosureInstruction::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, LastQtyDisclosureInstruction::Enum);

struct ONIXS_EUREX_ETI_EXPORT LeavesQtyDisclosureInstruction
{
    enum Enum
    {
        NoValue = 0xFF, 
        No = 0,         
        Yes = 1         
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(LeavesQtyDisclosureInstruction::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, LeavesQtyDisclosureInstruction::Enum);

struct ONIXS_EUREX_ETI_EXPORT LegInputSource
{
    enum Enum
    {
        NoValue = 0xFF,        
        ClientBroker = 1,      
        ProprietaryBroker = 2, 
        BuySide = 3,           
        SellSide = 4           
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(LegInputSource::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, LegInputSource::Enum);

struct ONIXS_EUREX_ETI_EXPORT LegPositionEffect
{
    enum Enum
    {
        NoValue = 0x00, 
        Close = 'C',    
        Open = 'O'      
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(LegPositionEffect::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, LegPositionEffect::Enum);

struct ONIXS_EUREX_ETI_EXPORT LegSecurityType
{
    enum Enum
    {
        NoValue = 0xFF,         
        MultilegInstrument = 1, 
        UnderlyingLeg = 2       
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(LegSecurityType::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, LegSecurityType::Enum);

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

ONIXS_EUREX_ETI_EXPORT std::string enumToString(LegSide::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, LegSide::Enum);

struct ONIXS_EUREX_ETI_EXPORT ListUpdateAction
{
    enum Enum
    {
        NoValue = 0x00, 
        Add = 'A',      
        Delete = 'D'    
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(ListUpdateAction::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, ListUpdateAction::Enum);

struct ONIXS_EUREX_ETI_EXPORT MDBookType
{
    enum Enum
    {
        NoValue = 0xFF, 
        TopOfBook = 1,  
        PriceDepth = 2  
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(MDBookType::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, MDBookType::Enum);

struct ONIXS_EUREX_ETI_EXPORT MDSubBookType
{
    enum Enum
    {
        NoValue = 0xFF,           
        Implied = 1,              
        VolumeWeightedAverage = 2 
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(MDSubBookType::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, MDSubBookType::Enum);

struct ONIXS_EUREX_ETI_EXPORT MMRiskLimitActionType
{
    enum Enum
    {
        NoValue = 0xFF,              
        QuoteInactivate = 1,         
        QuoteInactivateAndDelete = 2 
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(MMRiskLimitActionType::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, MMRiskLimitActionType::Enum);

struct ONIXS_EUREX_ETI_EXPORT MarketId
{
    enum Enum
    {
        NoValue = 0xFF, 
        XEUR = 1,       
        XEEE = 2,       
        NODX = 12       
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(MarketId::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, MarketId::Enum);

struct ONIXS_EUREX_ETI_EXPORT MassActionReason
{
    enum Enum
    {
        NoValue = 0xFF,                       
        NoSpecialReason = 0,                  
        StopTrading = 1,                      
        Emergency = 2,                        
        MarketMakerProtection = 3,            
        SessionLoss = 6,                      
        DuplicateSessionLogin = 7,            
        ClearingRiskControl = 8,              
        InternalConnectionLoss = 100,         
        ProductStateHalt = 105,               
        ProductStateHoliday = 106,            
        InstrumentSuspended = 107,            
        ComplexInstrumentDeletion = 109,      
        VolatilityInterruption = 110,         
        ProductTemporarilyNotTradeable = 111, 
        MemberDisable = 117,                  
        ScaledSimpleInstrumentDeletion = 121, 
        D2OrderCancellation = 122,            
        UserRiskGroupDisable = 123,           
        UserGroupHaltTrading = 124,           
        RiskMonitoringSessionLoss = 126,      
        RiskServiceUnavailable = 127          
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(MassActionReason::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, MassActionReason::Enum);

struct ONIXS_EUREX_ETI_EXPORT MassActionSubType
{
    enum Enum
    {
        NoValue = 0xFF,  
        BookOrCancel = 1 
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(MassActionSubType::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, MassActionSubType::Enum);

struct ONIXS_EUREX_ETI_EXPORT MassActionType
{
    enum Enum
    {
        NoValue = 0xFF,         
        SuspendQuotes = 1,      
        ReleaseQuotes = 2,      
        SuspendDeleteQuotes = 3 
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(MassActionType::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, MassActionType::Enum);

struct ONIXS_EUREX_ETI_EXPORT MatchSubType
{
    enum Enum
    {
        NoValue = 0xFF,            
        OpeningAuction = 1,        
        ClosingAuction = 2,        
        IntradayAuction = 3,       
        CircuitBreakerAuction = 4, 
        OutsideBBO = 6             
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(MatchSubType::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, MatchSubType::Enum);

struct ONIXS_EUREX_ETI_EXPORT MatchType
{
    enum Enum
    {
        NoValue = 0xFF,                
        ConfirmedTradeReport = 3,      
        AutoMatchIncoming = 4,         
        CrossAuction = 5,              
        CallAuction = 7,               
        AutoMatchResting = 11,         
        LiquidityImprovementCross = 13 
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(MatchType::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, MatchType::Enum);

struct ONIXS_EUREX_ETI_EXPORT MatchingEngineStatus
{
    enum Enum
    {
        NoValue = 0xFF,  
        Unavailable = 0, 
        Available = 1    
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(MatchingEngineStatus::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, MatchingEngineStatus::Enum);

struct ONIXS_EUREX_ETI_EXPORT MessageEventSource
{
    enum Enum
    {
        NoValue = 0x00,                 
        BroadcastToInitiator = 'I',     
        BroadcastToApprover = 'A',      
        BroadcastToRequester = 'R',     
        BroadcastToQuoteSubmitter = 'Q' 
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(MessageEventSource::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, MessageEventSource::Enum);

struct ONIXS_EUREX_ETI_EXPORT MultiLegReportingType
{
    enum Enum
    {
        NoValue = 0xFF,                      
        SingleSecurity = 1,                  
        IndividualLegOfAMultilegSecurity = 2 
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(MultiLegReportingType::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, MultiLegReportingType::Enum);

struct ONIXS_EUREX_ETI_EXPORT MultilegModel
{
    enum Enum
    {
        NoValue = 0xFF,                 
        PredefinedMultilegSecurity = 0, 
        UserDefinedMultleg = 1          
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(MultilegModel::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, MultilegModel::Enum);

struct ONIXS_EUREX_ETI_EXPORT MultilegPriceModel
{
    enum Enum
    {
        NoValue = 0xFF, 
        Standard = 0,   
        UserDefined = 1 
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(MultilegPriceModel::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, MultilegPriceModel::Enum);

struct ONIXS_EUREX_ETI_EXPORT NewsRtmServiceStatus
{
    enum Enum
    {
        NoValue = 0xFF,  
        Unavailable = 0, 
        Available = 1    
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(NewsRtmServiceStatus::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, NewsRtmServiceStatus::Enum);

struct ONIXS_EUREX_ETI_EXPORT NumberOfRespDisclosureInstruction
{
    enum Enum
    {
        NoValue = 0xFF, 
        No = 0,         
        Yes = 1         
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(NumberOfRespDisclosureInstruction::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, NumberOfRespDisclosureInstruction::Enum);

struct ONIXS_EUREX_ETI_EXPORT OfferPxIsLocked
{
    enum Enum
    {
        NoValue = 0xFF, 
        No = 0,         
        Yes = 1         
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(OfferPxIsLocked::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, OfferPxIsLocked::Enum);

struct ONIXS_EUREX_ETI_EXPORT OptionalEarlyTerminationIndicator
{
    enum Enum
    {
        NoValue = 0xFF, 
        No = 0,         
        Yes = 1         
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(OptionalEarlyTerminationIndicator::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, OptionalEarlyTerminationIndicator::Enum);

struct ONIXS_EUREX_ETI_EXPORT OrdStatus
{
    enum Enum
    {
        NoValue = 0x00,        
        New = '0',             
        PartiallyFilled = '1', 
        Filled = '2',          
        Canceled = '4',        
        PendingCancel = '6',   
        Suspended = '9'        
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(OrdStatus::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, OrdStatus::Enum);

struct ONIXS_EUREX_ETI_EXPORT OrdType
{
    enum Enum
    {
        NoValue = 0xFF, 
        Market = 1,     
        Limit = 2,      
        Stop = 3,       
        StopLimit = 4   
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(OrdType::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, OrdType::Enum);

struct ONIXS_EUREX_ETI_EXPORT OrderAttributeLiquidityProvision
{
    enum Enum
    {
        NoValue = 0xFF, 
        Y = 1,          
        N = 0           
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(OrderAttributeLiquidityProvision::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, OrderAttributeLiquidityProvision::Enum);

struct ONIXS_EUREX_ETI_EXPORT OrderAttributeRiskReduction
{
    enum Enum
    {
        NoValue = 0xFF, 
        Y = 1,          
        N = 0           
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(OrderAttributeRiskReduction::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, OrderAttributeRiskReduction::Enum);

struct ONIXS_EUREX_ETI_EXPORT OrderCategory
{
    enum Enum
    {
        NoValue = 0x00, 
        Order = '1',    
        Quote = '2'     
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(OrderCategory::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, OrderCategory::Enum);

struct ONIXS_EUREX_ETI_EXPORT OrderDeletionInstruction
{
    enum Enum
    {
        NoValue = 0xFF, 
        No = 0,         
        Yes = 1         
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(OrderDeletionInstruction::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, OrderDeletionInstruction::Enum);

struct ONIXS_EUREX_ETI_EXPORT OrderEventReason
{
    enum Enum
    {
        NoValue = 0xFF, 
        SMP = 100       
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(OrderEventReason::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, OrderEventReason::Enum);

struct ONIXS_EUREX_ETI_EXPORT OrderOrigination
{
    enum Enum
    {
        NoValue = 0xFF,               
        DirectAccessCustomer = 5,     
        SponsoredAccessCustomer = 105 
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(OrderOrigination::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, OrderOrigination::Enum);

struct ONIXS_EUREX_ETI_EXPORT OrderQtyDisclosureInstruction
{
    enum Enum
    {
        NoValue = 0xFF, 
        No = 0,         
        Yes = 1         
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(OrderQtyDisclosureInstruction::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, OrderQtyDisclosureInstruction::Enum);

struct ONIXS_EUREX_ETI_EXPORT OrderQtyIsLocked
{
    enum Enum
    {
        NoValue = 0xFF, 
        No = 0,         
        Yes = 1         
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(OrderQtyIsLocked::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, OrderQtyIsLocked::Enum);

struct ONIXS_EUREX_ETI_EXPORT OrderSide
{
    enum Enum
    {
        NoValue = 0xFF, 
        Buy = 1,        
        Sell = 2        
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(OrderSide::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, OrderSide::Enum);

struct ONIXS_EUREX_ETI_EXPORT OwnershipIndicator
{
    enum Enum
    {
        NoValue = 0xFF,             
        NoChangeOfOwnership = 0,    
        ChangeToExecutingTrader = 1 
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(OwnershipIndicator::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, OwnershipIndicator::Enum);

struct ONIXS_EUREX_ETI_EXPORT PartyActionType
{
    enum Enum
    {
        NoValue = 0xFF,  
        HaltTrading = 1, 
        Reinstate = 2    
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(PartyActionType::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, PartyActionType::Enum);

struct ONIXS_EUREX_ETI_EXPORT PartyDetailRoleQualifier
{
    enum Enum
    {
        NoValue = 0xFF,  
        Trader = 10,     
        HeadTrader = 11, 
        Supervisor = 12  
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(PartyDetailRoleQualifier::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, PartyDetailRoleQualifier::Enum);

struct ONIXS_EUREX_ETI_EXPORT PartyDetailStatus
{
    enum Enum
    {
        NoValue = 0xFF, 
        Active = 0,     
        Suspend = 1,    
        Rejected = 2    
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(PartyDetailStatus::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, PartyDetailStatus::Enum);

struct ONIXS_EUREX_ETI_EXPORT PartyDetailStatusInformation
{
    enum Enum
    {
        NoValue = 0xFF,         
        TRRTHRESHOLDTOOBIG = 1, 
        BLOCKALLANONYMOUS = 2   
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(PartyDetailStatusInformation::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, PartyDetailStatusInformation::Enum);

struct ONIXS_EUREX_ETI_EXPORT PartyIdEnteringFirm
{
    enum Enum
    {
        NoValue = 0xFF,       
        Participant = 1,      
        MarketSupervision = 2 
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(PartyIdEnteringFirm::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, PartyIdEnteringFirm::Enum);

struct ONIXS_EUREX_ETI_EXPORT PartyIdOriginationMarket
{
    enum Enum
    {
        NoValue = 0xFF, 
        XKFE = 1        
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(PartyIdOriginationMarket::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, PartyIdOriginationMarket::Enum);

struct ONIXS_EUREX_ETI_EXPORT PartyIdSettlementLocation
{
    enum Enum
    {
        NoValue = 0xFF,                 
        ClearstremBankingFrankfurt = 1, 
        ClearstremBankingLuxemburg = 2, 
        CLSGroup = 3,                   
        Euroclear = 4                   
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(PartyIdSettlementLocation::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, PartyIdSettlementLocation::Enum);

struct ONIXS_EUREX_ETI_EXPORT PartyIdInvestmentDecisionMakerQualifier
{
    enum Enum
    {
        NoValue = 0xFF, 
        Algo = 22,      
        Human = 24      
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(PartyIdInvestmentDecisionMakerQualifier::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, PartyIdInvestmentDecisionMakerQualifier::Enum);

struct ONIXS_EUREX_ETI_EXPORT PartyOrderOriginationDisclosureInstruction
{
    enum Enum
    {
        NoValue = 0xFF, 
        No = 0,         
        Yes = 1         
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(PartyOrderOriginationDisclosureInstruction::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, PartyOrderOriginationDisclosureInstruction::Enum);

struct ONIXS_EUREX_ETI_EXPORT PartySubIdType
{
    enum Enum
    {
        NoValue = 0xFF, 
        Buyer = 14001,  
        Seller = 14002  
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(PartySubIdType::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, PartySubIdType::Enum);

struct ONIXS_EUREX_ETI_EXPORT PositionEffect
{
    enum Enum
    {
        NoValue = 0x00, 
        Close = 'C',    
        Open = 'O'      
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(PositionEffect::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, PositionEffect::Enum);

struct ONIXS_EUREX_ETI_EXPORT PriceDisclosureInstruction
{
    enum Enum
    {
        NoValue = 0xFF, 
        No = 0,         
        Yes = 1         
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(PriceDisclosureInstruction::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, PriceDisclosureInstruction::Enum);

struct ONIXS_EUREX_ETI_EXPORT PriceValidityCheckType
{
    enum Enum
    {
        NoValue = 0xFF, 
        None = 0,       
        Optional = 1,   
        Mandatory = 2   
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(PriceValidityCheckType::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, PriceValidityCheckType::Enum);

struct ONIXS_EUREX_ETI_EXPORT ProductComplex
{
    enum Enum
    {
        NoValue = 0xFF,                     
        SimpleInstrument = 1,               
        StandardOptionStrategy = 2,         
        NonStandardOptionStrategy = 3,      
        VolatilityStrategy = 4,             
        FuturesSpread = 5,                  
        InterProductSpread = 6,             
        StandardFutureStrategy = 7,         
        PackAndBundle = 8,                  
        Strip = 9,                          
        FlexibleSimpleInstrument = 10,      
        CommodityStrip = 11,                
        ScaledSimpleInstrument = 12,        
        NonStandardVolatilityStrategy = 13, 
        TotalReturnFutureStrategy = 14      
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(ProductComplex::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, ProductComplex::Enum);

struct ONIXS_EUREX_ETI_EXPORT PutOrCall
{
    enum Enum
    {
        NoValue = 0xFF, 
        Put = 0,        
        Call = 1        
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(PutOrCall::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, PutOrCall::Enum);

struct ONIXS_EUREX_ETI_EXPORT QuoteCancelReason
{
    enum Enum
    {
        NoValue = 0xFF, 
        Expired = 5     
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(QuoteCancelReason::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, QuoteCancelReason::Enum);

struct ONIXS_EUREX_ETI_EXPORT QuoteCondition
{
    enum Enum
    {
        NoValue = 0x00,  
        Active = 'A',    
        Closed = 'B',    
        Suspended = 'z', 
        Expired = '8'    
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(QuoteCondition::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, QuoteCondition::Enum);

struct ONIXS_EUREX_ETI_EXPORT QuoteEntryRejectReason
{
    enum Enum
    {
        NoValue = 0xFF,                                    
        UnknownSecurity = 1,                               
        DuplicateQuote = 6,                                
        InvalidPrice = 8,                                  
        NoReferencePriceAvailable = 16,                    
        NoSingleSidedQuotes = 100,                         
        InvalidQuotingModel = 103,                         
        InvalidSize = 106,                                 
        InvalidUnderlyingPrice = 107,                      
        BidPriceNotReasonable = 108,                       
        AskPriceNotReasonable = 109,                       
        BidPriceExceedsRange = 110,                        
        AskPriceExceedsRange = 111,                        
        InstrumentStateFreeze = 115,                       
        DeletionAlreadyPending = 116,                      
        EntitlementNotAssignedForUnderlying = 119,         
        CurrentlyNotTradeableOnBook = 124,                 
        QuantityLimitExceeded = 125,                       
        ValueLimitExceeded = 126,                          
        InvalidQuoteSpread = 127,                          
        BookOrCancel = 128,                                
        CantProcInCurrInstrState = 131,                    
        InvalidQuoteType = 134,                            
        TradingIndicationRunningForTrader = 143,           
        OnBookTradingDisabledForInstrumentType = 144,      
        LiquidityProviderProtectionBidSideCancelled = 147, 
        LiquidityProviderProtectionAskSideCancelled = 148, 
        OutsideQuotingPeriod = 155,                        
        MatchPriceNotOnPriceStep = 156, 
        QuantityLimitExceedsTSL = 161,  
        TooManyOrdersAndQuotesInOrderBook = 163,                  
        ContractCannotBeTradedDueToInsufficientEligibility = 166, 
        UnderlyingPriceTimeout = 167,       
        BUSuspendARPLevel3SoftBreach = 168, 
        NoClearingProductAssignment = 169,  
        ValueLimitExceededProduct = 170,    
        D2OrderCancellation = 171           
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(QuoteEntryRejectReason::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, QuoteEntryRejectReason::Enum);

struct ONIXS_EUREX_ETI_EXPORT QuoteEntryStatus
{
    enum Enum
    {
        NoValue = 0xFF,         
        Accepted = 0,           
        Rejected = 5,           
        RemovedAndRejected = 6, 
        Pending = 10            
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(QuoteEntryStatus::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, QuoteEntryStatus::Enum);

struct ONIXS_EUREX_ETI_EXPORT QuoteEventLiquidityInd
{
    enum Enum
    {
        NoValue = 0xFF,       
        AddedLiquidity = 1,   
        RemovedLiquidity = 2, 
        Auction = 4           
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(QuoteEventLiquidityInd::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, QuoteEventLiquidityInd::Enum);

struct ONIXS_EUREX_ETI_EXPORT QuoteEventReason
{
    enum Enum
    {
        NoValue = 0xFF,                   
        PendingCancellationExecuted = 14, 
        InvalidPrice = 15,                
        CrossRejected = 16,               
        BookOrCancel = 17,                
        PLP = 18                          
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(QuoteEventReason::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, QuoteEventReason::Enum);

struct ONIXS_EUREX_ETI_EXPORT QuoteEventSide
{
    enum Enum
    {
        NoValue = 0xFF, 
        Buy = 1,        
        Sell = 2        
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(QuoteEventSide::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, QuoteEventSide::Enum);

struct ONIXS_EUREX_ETI_EXPORT QuoteEventType
{
    enum Enum
    {
        NoValue = 0xFF,       
        RemovedQuoteSide = 3, 
        PartiallyFilled = 4,  
        Filled = 5,           
        RemovedQuantity = 6   
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(QuoteEventType::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, QuoteEventType::Enum);

struct ONIXS_EUREX_ETI_EXPORT QuoteInstruction
{
    enum Enum
    {
        NoValue = 0xFF, 
        DoNotQuote = 0, 
        Quote = 1       
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(QuoteInstruction::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, QuoteInstruction::Enum);

struct ONIXS_EUREX_ETI_EXPORT QuoteSizeType
{
    enum Enum
    {
        NoValue = 0xFF, 
        TotalSize = 1,  
        OpenSize = 2    
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(QuoteSizeType::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, QuoteSizeType::Enum);

struct ONIXS_EUREX_ETI_EXPORT QuoteSubType
{
    enum Enum
    {
        NoValue = 0xFF,                         
        WorkingDelta = 1,                       
        BasisTrade = 2,                         
        Regular = 3,                            
        NegotiateUnderlyingOutsideExchange = 4, 
        VolaStrategyFix = 5,                    
        VolaStrategyNegotiateUnderlying = 6     
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(QuoteSubType::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, QuoteSubType::Enum);

struct ONIXS_EUREX_ETI_EXPORT QuoteType
{
    enum Enum
    {
        NoValue = 0xFF,    
        Indicative = 0,    
        Tradeable = 1,     
        TradeableBOC = 100 
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(QuoteType::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, QuoteType::Enum);

struct ONIXS_EUREX_ETI_EXPORT QuotingStatus
{
    enum Enum
    {
        NoValue = 0xFF,    
        OpenActive = 1,    
        OpenIdle = 2,      
        ClosedInactive = 3 
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(QuotingStatus::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, QuotingStatus::Enum);

struct ONIXS_EUREX_ETI_EXPORT RefApplId
{
    enum Enum
    {
        NoValue = 0xFF,                
        Trade = 1,                     
        News = 2,                      
        ServiceAvailability = 3,       
        SessionData = 4,               
        ListenerData = 5,              
        RiskControl = 6,               
        TESMaintenance = 7,            
        TESTrade = 8,                  
        SRQSMaintenance = 9,           
        ServiceAvailabilityMarket = 10 
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(RefApplId::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, RefApplId::Enum);

struct ONIXS_EUREX_ETI_EXPORT RelatedProductComplex
{
    enum Enum
    {
        NoValue = 0xFF,                     
        StandardOptionStrategy = 2,         
        NonStandardOptionStrategy = 3,      
        VolatilityStrategy = 4,             
        FuturesSpread = 5,                  
        InterProductSpread = 6,             
        StandardFutureStrategy = 7,         
        PackAndBundle = 8,                  
        Strip = 9,                          
        CommodityStrip = 11,                
        ScaledSimpleInstrument = 12,        
        NonStandardVolatilityStrategy = 13, 
        TotalReturnFutureStrategy = 14      
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(RelatedProductComplex::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, RelatedProductComplex::Enum);

struct ONIXS_EUREX_ETI_EXPORT RequestingPartyIdEnteringFirm
{
    enum Enum
    {
        NoValue = 0xFF,       
        Participant = 1,      
        MarketSupervision = 2 
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(RequestingPartyIdEnteringFirm::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, RequestingPartyIdEnteringFirm::Enum);

struct ONIXS_EUREX_ETI_EXPORT RequestingPartyIdExecutingSystem
{
    enum Enum
    {
        NoValue = 0xFF,    
        EurexClearing = 1, 
        T7 = 2             
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(RequestingPartyIdExecutingSystem::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, RequestingPartyIdExecutingSystem::Enum);

struct ONIXS_EUREX_ETI_EXPORT RequestingPartySubIdType
{
    enum Enum
    {
        NoValue = 0xFF,   
        Requester = 5000, 
        Responder = 5001, 
        Both = 5002,      
        System = 5003     
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(RequestingPartySubIdType::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, RequestingPartySubIdType::Enum);

struct ONIXS_EUREX_ETI_EXPORT RespondentType
{
    enum Enum
    {
        NoValue = 0xFF,            
        AllMarketParticipants = 1, 
        Anonymous = 102 
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(RespondentType::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, RespondentType::Enum);

struct ONIXS_EUREX_ETI_EXPORT ReversalCancellationReason
{
    enum Enum
    {
        NoValue = 0xFF,          
        TASChange = 1,           
        IntradayExpiration = 2,  
        InstrumentDeletion = 3,  
        InstrumentSuspension = 4 
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(ReversalCancellationReason::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, ReversalCancellationReason::Enum);

struct ONIXS_EUREX_ETI_EXPORT ReversalIndicator
{
    enum Enum
    {
        NoValue = 0xFF, 
        No = 0,         
        Yes = 1         
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(ReversalIndicator::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, ReversalIndicator::Enum);

struct ONIXS_EUREX_ETI_EXPORT RiskControlRtmServiceStatus
{
    enum Enum
    {
        NoValue = 0xFF,  
        Unavailable = 0, 
        Available = 1    
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(RiskControlRtmServiceStatus::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, RiskControlRtmServiceStatus::Enum);

struct ONIXS_EUREX_ETI_EXPORT RiskLimitAction
{
    enum Enum
    {
        NoValue = 0xFF,   
        QueueInbound = 0, 
        Reject = 2,       
        Warning = 4       
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(RiskLimitAction::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, RiskLimitAction::Enum);

struct ONIXS_EUREX_ETI_EXPORT RiskLimitGroupStatus
{
    enum Enum
    {
        NoValue = 0xFF, 
        Active = 0,     
        Suspend = 1     
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(RiskLimitGroupStatus::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, RiskLimitGroupStatus::Enum);

struct ONIXS_EUREX_ETI_EXPORT RiskLimitPlatform
{
    enum Enum
    {
        NoValue = 0xFF, 
        OnBook = 0,     
        OffBook = 1     
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(RiskLimitPlatform::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, RiskLimitPlatform::Enum);

struct ONIXS_EUREX_ETI_EXPORT RiskLimitRequestingPartyRole
{
    enum Enum
    {
        NoValue = 0xFF,    
        ClearingFirm = 4,  
        Exchange = 22,     
        ExecutingUnit = 59 
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(RiskLimitRequestingPartyRole::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, RiskLimitRequestingPartyRole::Enum);

struct ONIXS_EUREX_ETI_EXPORT RiskLimitResult
{
    enum Enum
    {
        NoValue = 0xFF,        
        DisabledForBu = 10580, 
        LowRRAEventID = 10581, 
        HighRRAEventID = 10582 
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(RiskLimitResult::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, RiskLimitResult::Enum);

struct ONIXS_EUREX_ETI_EXPORT RiskLimitType
{
    enum Enum
    {
        NoValue = 0xFF, 
        GrossLimit = 1, 
        NetLimit = 2,   
        LongLimit = 4,  
        ShortLimit = 5  
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(RiskLimitType::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, RiskLimitType::Enum);

struct ONIXS_EUREX_ETI_EXPORT RiskLimitViolationIndicator
{
    enum Enum
    {
        NoValue = 0xFF, 
        No = 0,         
        Yes = 1         
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(RiskLimitViolationIndicator::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, RiskLimitViolationIndicator::Enum);

struct ONIXS_EUREX_ETI_EXPORT RootPartyIdInvestmentDecisionMakerQualifier
{
    enum Enum
    {
        NoValue = 0xFF, 
        Algo = 22,      
        Human = 24      
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(RootPartyIdInvestmentDecisionMakerQualifier::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, RootPartyIdInvestmentDecisionMakerQualifier::Enum);

struct ONIXS_EUREX_ETI_EXPORT RootPartySubIdType
{
    enum Enum
    {
        NoValue = 0xFF, 
        Buyer = 4001,   
        Seller = 4002,  
        Broker = 4003   
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(RootPartySubIdType::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, RootPartySubIdType::Enum);

struct ONIXS_EUREX_ETI_EXPORT SecondaryGatewayStatus
{
    enum Enum
    {
        NoValue = 0xFF, 
        Standby = 0,    
        Active = 1      
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(SecondaryGatewayStatus::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, SecondaryGatewayStatus::Enum);

struct ONIXS_EUREX_ETI_EXPORT SelectiveRequestForQuoteRtmServiceStatus
{
    enum Enum
    {
        NoValue = 0xFF,  
        Unavailable = 0, 
        Available = 1    
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(SelectiveRequestForQuoteRtmServiceStatus::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, SelectiveRequestForQuoteRtmServiceStatus::Enum);

struct ONIXS_EUREX_ETI_EXPORT SelectiveRequestForQuoteServiceStatus
{
    enum Enum
    {
        NoValue = 0xFF,  
        Unavailable = 0, 
        Available = 1    
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(SelectiveRequestForQuoteServiceStatus::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, SelectiveRequestForQuoteServiceStatus::Enum);

struct ONIXS_EUREX_ETI_EXPORT SelfMatchPreventionInstruction
{
    enum Enum
    {
        NoValue = 0xFF,           
        CrossRejectedBU = 100,    
        CrossRejectedMarket = 101 
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(SelfMatchPreventionInstruction::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, SelfMatchPreventionInstruction::Enum);

struct ONIXS_EUREX_ETI_EXPORT SessionMode
{
    enum Enum
    {
        NoValue = 0xFF, 
        ETIHF = 1,      
        ETILF = 2,      
        GUI = 3,        
        FIXLF = 4       
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(SessionMode::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, SessionMode::Enum);

struct ONIXS_EUREX_ETI_EXPORT SessionRejectReason
{
    enum Enum
    {
        NoValue = 0xFF,                             
        RequiredTagMissing = 1,                     
        ValueIsIncorrect = 5,                       
        DecryptionProblem = 7,                      
        InvalidMsgID = 11,                          
        IncorrectNumInGroupCount = 16,              
        Other = 99,                                 
        ThrottleLimitExceeded = 100,                
        ExposureLimitExceeded = 101,                
        ServiceTemporarilyNotAvailable = 102,       
        ServiceNotAvailable = 103,                  
        OutboundConversionError = 105,              
        HeartbeatViolation = 152,                   
        InternalTechnicalError = 200,               
        ValidationError = 210,                      
        UserAlreadyLoggedIn = 211,                  
        GatewayIsStandby = 216,                     
        SessionLoginLimitReached = 217,             
        UserEntitlementDataTimeout = 223,           
        PSGatewaySessionLimitReached = 224,         
        UserLoginLimitReached = 225,                
        OutstandingLoginsBuLimitReached = 226,      
        OutstandingLoginsSessionLimitReached = 227, 
        PasswordTimestampNotInGracePeriod = 228,    
        OrderNotFound = 10000,                      
        PriceNotReasonable = 10001,                 
        ClientOrderIDNotUnique = 10002,             
        QuoteActivationInProgress = 10003, 
        StopBidPriceNotReasonable = 10006, 
        StopAskPriceNotReasonable = 10007, 
        OrderNotExecutableWithinValidity = 10008,    
        CreateCIThrottleExceeded = 10010,            
        TransactionNotAllowedInCurrentState = 10011, 
        RequiredMinLotSizeNotReached = 10013,        
        PretradeRiskLimitExceeded = 10016            
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(SessionRejectReason::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, SessionRejectReason::Enum);

struct ONIXS_EUREX_ETI_EXPORT SessionStatus
{
    enum Enum
    {
        NoValue = 0xFF, 
        Active = 0,     
        Logout = 4      
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(SessionStatus::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, SessionStatus::Enum);

struct ONIXS_EUREX_ETI_EXPORT SessionSubMode
{
    enum Enum
    {
        NoValue = 0xFF,                      
        RegularTradingSession = 0,           
        RegularBackOfficeSession = 2,        
        SponsoredAccessTradingSession = 4,   
        SponsoredAccessBackOfficeSession = 5 
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(SessionSubMode::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, SessionSubMode::Enum);

struct ONIXS_EUREX_ETI_EXPORT SettlMethod
{
    enum Enum
    {
        NoValue = 0x00,          
        CashSettlement = 'C',    
        PhysicalSettlement = 'P' 
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(SettlMethod::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, SettlMethod::Enum);

struct ONIXS_EUREX_ETI_EXPORT ShowLastDealOnClosure
{
    enum Enum
    {
        NoValue = 0xFF, 
        No = 0,         
        Yes = 1         
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(ShowLastDealOnClosure::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, ShowLastDealOnClosure::Enum);

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

ONIXS_EUREX_ETI_EXPORT std::string enumToString(Side::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, Side::Enum);

struct ONIXS_EUREX_ETI_EXPORT SideDisclosureInstruction
{
    enum Enum
    {
        NoValue = 0xFF, 
        No = 0,         
        Yes = 1         
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(SideDisclosureInstruction::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, SideDisclosureInstruction::Enum);

struct ONIXS_EUREX_ETI_EXPORT SideIsLocked
{
    enum Enum
    {
        NoValue = 0xFF, 
        No = 0,         
        Yes = 1         
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(SideIsLocked::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, SideIsLocked::Enum);

struct ONIXS_EUREX_ETI_EXPORT SideLiquidityInd
{
    enum Enum
    {
        NoValue = 0xFF,       
        AddedLiquidity = 1,   
        RemovedLiquidity = 2, 
        Auction = 4           
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(SideLiquidityInd::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, SideLiquidityInd::Enum);

struct ONIXS_EUREX_ETI_EXPORT SideTrdSubTyp
{
    enum Enum
    {
        NoValue = 0xFF,      
        BlockTrade = 2001,   
        TradeAtMarket = 2004 
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(SideTrdSubTyp::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, SideTrdSubTyp::Enum);

struct ONIXS_EUREX_ETI_EXPORT SkipValidations
{
    enum Enum
    {
        NoValue = 0xFF, 
        False = 0,      
        True = 1        
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(SkipValidations::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, SkipValidations::Enum);

struct ONIXS_EUREX_ETI_EXPORT SwapClearer
{
    enum Enum
    {
        NoValue = 0xFF, 
        ECAG = 0,       
        NONECAG = 1     
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(SwapClearer::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, SwapClearer::Enum);

struct ONIXS_EUREX_ETI_EXPORT T7EntryServiceRtmStatus
{
    enum Enum
    {
        NoValue = 0xFF,  
        Unavailable = 0, 
        Available = 1    
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(T7EntryServiceRtmStatus::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, T7EntryServiceRtmStatus::Enum);

struct ONIXS_EUREX_ETI_EXPORT T7EntryServiceStatus
{
    enum Enum
    {
        NoValue = 0xFF,  
        Unavailable = 0, 
        Available = 1    
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(T7EntryServiceStatus::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, T7EntryServiceStatus::Enum);

struct ONIXS_EUREX_ETI_EXPORT TimeInForce
{
    enum Enum
    {
        NoValue = 0xFF, 
        Day = 0,        
        GTC = 1,        
        IOC = 3,        
        FOK = 4,        
        GTD = 6         
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(TimeInForce::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, TimeInForce::Enum);

struct ONIXS_EUREX_ETI_EXPORT TradSesEvent
{
    enum Enum
    {
        NoValue = 0xFF,         
        StartOfService = 101,   
        MarketReset = 102,      
        EndOfRestatement = 103, 
        EndOfDayService = 104,  
        ServiceResumed = 105    
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(TradSesEvent::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, TradSesEvent::Enum);

struct ONIXS_EUREX_ETI_EXPORT TradSesMode
{
    enum Enum
    {
        NoValue = 0xFF,      
        Testing = 1,         
        Simulated = 2,       
        Production = 3,      
        Acceptance = 4,      
        DisasterRecovery = 5 
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(TradSesMode::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, TradSesMode::Enum);

struct ONIXS_EUREX_ETI_EXPORT TradeAggregationTransType
{
    enum Enum
    {
        NoValue = 0xFF, 
        New = 0         
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(TradeAggregationTransType::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, TradeAggregationTransType::Enum);

struct ONIXS_EUREX_ETI_EXPORT TradeAllocStatus
{
    enum Enum
    {
        NoValue = 0xFF,           
        Pending = 1,              
        Approved = 2,             
        AutoApproved = 3,         
        Uploaded = 4,             
        Canceled = 5,             
        PendingReversal = 7,      
        ApprovedReversal = 8,     
        Reversed = 9,             
        CancelledReversal = 10,   
        AutoApprovedReversal = 11 
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(TradeAllocStatus::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, TradeAllocStatus::Enum);

struct ONIXS_EUREX_ETI_EXPORT TradeManagerStatus
{
    enum Enum
    {
        NoValue = 0xFF,  
        Unavailable = 0, 
        Available = 1    
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(TradeManagerStatus::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, TradeManagerStatus::Enum);

struct ONIXS_EUREX_ETI_EXPORT TradePlatform
{
    enum Enum
    {
        NoValue = 0xFF, 
        OffBook = 0,    
        OnBook = 1      
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(TradePlatform::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, TradePlatform::Enum);

struct ONIXS_EUREX_ETI_EXPORT TradePublishIndicator
{
    enum Enum
    {
        NoValue = 0xFF,          
        DoNotPublishTrade = 0,   
        PublishTrade = 1,        
        DeferredPublication = 2, 
        Published = 3            
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(TradePublishIndicator::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, TradePublishIndicator::Enum);

struct ONIXS_EUREX_ETI_EXPORT TradeReportType
{
    enum Enum
    {
        NoValue = 0xFF,        
        Submit = 0,            
        Alleged = 1,           
        Accept = 2,            
        Decline = 3,           
        NoWasReplaced = 5,     
        TradeReportCancel = 6, 
        TradeBreak = 7,        
        AllegedNew = 11,       
        AllegedNoWas = 13      
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(TradeReportType::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, TradeReportType::Enum);

struct ONIXS_EUREX_ETI_EXPORT TradeRequestResult
{
    enum Enum
    {
        NoValue = 0xFF,       
        CancelPending = 100,  
        CancelDeclined = 101, 
        CancelApproved = 102  
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(TradeRequestResult::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, TradeRequestResult::Enum);

struct ONIXS_EUREX_ETI_EXPORT TradeToQuoteRatioRanking
{
    enum Enum
    {
        NoValue = 0xFF, 
        Low = 1,        
        Medium = 2,     
        High = 3        
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(TradeToQuoteRatioRanking::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, TradeToQuoteRatioRanking::Enum);

struct ONIXS_EUREX_ETI_EXPORT TradingCapacity
{
    enum Enum
    {
        NoValue = 0xFF, 
        Customer = 1,   
        Principal = 5,  
        MarketMaker = 6 
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(TradingCapacity::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, TradingCapacity::Enum);

struct ONIXS_EUREX_ETI_EXPORT TradingSessionSubId
{
    enum Enum
    {
        NoValue = 0xFF,     
        OpeningAuction = 2, 
        ClosingAuction = 4, 
        AnyAuction = 8      
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(TradingSessionSubId::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, TradingSessionSubId::Enum);

struct ONIXS_EUREX_ETI_EXPORT TransactionDelayIndicator
{
    enum Enum
    {
        NoValue = 0xFF, 
        NotDelayed = 0, 
        Delayed = 1     
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(TransactionDelayIndicator::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, TransactionDelayIndicator::Enum);

struct ONIXS_EUREX_ETI_EXPORT TransferReason
{
    enum Enum
    {
        NoValue = 0xFF, 
        Owner = 1,      
        Clearer = 2     
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(TransferReason::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, TransferReason::Enum);

struct ONIXS_EUREX_ETI_EXPORT TrdRptStatus
{
    enum Enum
    {
        NoValue = 0xFF,    
        Accepted = 0,      
        Rejected = 1,      
        Cancelled = 2,     
        PendingNew = 4,    
        PendingCancel = 5, 
        Terminated = 7,    
        DeemedVerified = 9 
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(TrdRptStatus::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, TrdRptStatus::Enum);

struct ONIXS_EUREX_ETI_EXPORT TrdType
{
    enum Enum
    {
        NoValue = 0xFF,              
        BlockTrade = 1,              
        ExchangeForSwap = 12,        
        VolaTrade = 1000,            
        EFPFinTrade = 1001,          
        EFPIndexFuturesTrade = 1002, 
        TradeAtMarket = 1004,        
        Enlight = 1006,              
        BLOCKQTPIP = 1007,           
        BTRF = 1010,                 
        EBB = 1011                   
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(TrdType::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, TrdType::Enum);

struct ONIXS_EUREX_ETI_EXPORT Triggered
{
    enum Enum
    {
        NoValue = 0xFF,    
        NotTriggered = 0,  
        TriggeredStop = 1, 
        TriggeredOCO = 2   
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(Triggered::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, Triggered::Enum);

struct ONIXS_EUREX_ETI_EXPORT UserStatus
{
    enum Enum
    {
        NoValue = 0xFF,       
        UserForcedLogout = 7, 
        UserStopped = 10,     
        UserReleased = 11     
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(UserStatus::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, UserStatus::Enum);

struct ONIXS_EUREX_ETI_EXPORT ValueCheckTypeMinLotSize
{
    enum Enum
    {
        NoValue = 0xFF, 
        DoNotCheck = 0, 
        Check = 1       
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(ValueCheckTypeMinLotSize::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, ValueCheckTypeMinLotSize::Enum);

struct ONIXS_EUREX_ETI_EXPORT ValueCheckTypeQuantity
{
    enum Enum
    {
        NoValue = 0xFF, 
        DoNotCheck = 0, 
        Check = 1       
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(ValueCheckTypeQuantity::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, ValueCheckTypeQuantity::Enum);

struct ONIXS_EUREX_ETI_EXPORT ValueCheckTypeValue
{
    enum Enum
    {
        NoValue = 0xFF, 
        DoNotCheck = 0, 
        Check = 1       
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(ValueCheckTypeValue::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, ValueCheckTypeValue::Enum);

struct ONIXS_EUREX_ETI_EXPORT TemplateId
{
    enum Enum
    {
        Unknown = 0,                                      
        AddComplexInstrumentRequest = 10301,              
        AddComplexInstrumentResponse = 10302,             
        AddFlexibleInstrumentRequest = 10309,             
        AddFlexibleInstrumentResponse = 10310,            
        AddScaledSimpleInstrumentRequest = 10327,         
        AddScaledSimpleInstrumentResponse = 10328,        
        AmendBasketTradeRequest = 10629,                  
        ApproveBasketTradeRequest = 10623,                
        ApproveReverseTESTradeRequest = 10631,            
        ApproveTESTradeRequest = 10603,                   
        BasketApproveBroadcast = 10627,                   
        BasketBroadcast = 10625,                          
        BasketDeleteBroadcast = 10626,                    
        BasketExecutionBroadcast = 10628,                 
        BasketResponse = 10624,                           
        BasketRollBroadcast = 10634,                      
        BasketRollRequest = 10633,                        
        BroadcastErrorNotification = 10032,               
        CLIPDeletionNotification = 10134,                 
        CLIPExecutionNotification = 10135,                
        CLIPResponse = 10133,                             
        CrossRequest = 10118,                             
        CrossRequestResponse = 10119,                     
        DeleteAllOrderBroadcast = 10122,                  
        DeleteAllOrderNRResponse = 10124,                 
        DeleteAllOrderQuoteEventBroadcast = 10308,        
        DeleteAllOrderRequest = 10120,                    
        DeleteAllOrderResponse = 10121,                   
        DeleteAllQuoteBroadcast = 10410,                  
        DeleteAllQuoteRequest = 10408,                    
        DeleteAllQuoteResponse = 10409,                   
        DeleteBasketTradeRequest = 10622,                 
        DeleteCLIPRequest = 10132,                        
        DeleteOrderBroadcast = 10112,                     
        DeleteOrderNRResponse = 10111,                    
        DeleteOrderRequest = 10142,                       
        DeleteOrderResponse = 10110,                      
        DeleteTESTradeRequest = 10602,                    
        EnterBasketTradeRequest = 10620,                  
        EnterCLIPRequest = 10131,                         
        EnterTESTradeRequest = 10600,                     
        ForcedLogoutNotification = 10012,                 
        ForcedUserLogoutNotification = 10043,             
        Heartbeat = 10011,                                
        HeartbeatNotification = 10023,                    
        InquireEnrichmentRuleIdListRequest = 10040,       
        InquireEnrichmentRuleIdListResponse = 10041,      
        InquireMMParameterRequest = 10305,                
        InquireMMParameterResponse = 10306,               
        InquireMarginBasedRiskLimitRequest = 10323,       
        InquireMarginBasedRiskLimitResponse = 10324,      
        InquirePreTradeRiskLimitsRequest = 10311,         
        InquireSessionListRequest = 10035,                
        InquireSessionListResponse = 10036,               
        InquireUserRequest = 10038,                       
        InquireUserResponse = 10039,                      
        LegalNotificationBroadcast = 10037,               
        LogonRequest = 10000,                             
        LogonRequestEncrypted = 19000,                    
        LogonResponse = 10001,                            
        LogoutRequest = 10002,                            
        LogoutResponse = 10003,                           
        MMParameterDefinitionRequest = 10303,             
        MMParameterDefinitionResponse = 10304,            
        MassOrder = 10115,                                
        MassOrderAck = 10116,                             
        MassQuoteRequest = 10405,                         
        MassQuoteResponse = 10406,                        
        ModifyBasketTradeRequest = 10621,                 
        ModifyOrderNRResponse = 10108,                    
        ModifyOrderRequest = 10140,                       
        ModifyOrderResponse = 10107,                      
        ModifyOrderShortRequest = 10141,                  
        ModifyTESTradeRequest = 10601,                    
        NewOrderNRResponse = 10102,                       
        NewOrderRequest = 10138,                          
        NewOrderResponse = 10101,                         
        NewOrderShortRequest = 10139,                     
        NewsBroadcast = 10031,                            
        OrderExecNotification = 10104,                    
        OrderExecReportBroadcast = 10117,                 
        OrderExecResponse = 10103,                        
        PartyActionReport = 10042,                        
        PartyEntitlementsUpdateReport = 10034,            
        PingRequest = 10320,                              
        PingResponse = 10321,                             
        PreTradeRiskLimitResponse = 10313,                
        PreTradeRiskLimitsDefinitionRequest = 10312,      
        QuoteActivationNotification = 10411,              
        QuoteActivationRequest = 10403,                   
        QuoteActivationResponse = 10404,                  
        QuoteExecutionReport = 10407,                     
        RFQRequest = 10401,                               
        RFQResponse = 10402,                              
        Reject = 10010,                                   
        RetransmitMEMessageRequest = 10026,               
        RetransmitMEMessageResponse = 10027,              
        RetransmitRequest = 10008,                        
        RetransmitResponse = 10009,                       
        ReverseTESTradeRequest = 10630,                   
        RiskNotificationBroadcast = 10033,                
        SRQSCreateDealNotification = 10708,               
        SRQSDealNotification = 10709,                     
        SRQSDealResponse = 10705,                         
        SRQSEnterQuoteRequest = 10702,                    
        SRQSHitQuoteRequest = 10704,                      
        SRQSInquireSmartRespondentRequest = 10718,        
        SRQSInquireSmartRespondentResponse = 10719,       
        SRQSNegotiationNotification = 10713,              
        SRQSNegotiationRequesterNotification = 10712,     
        SRQSNegotiationStatusNotification = 10715,        
        SRQSOpenNegotiationNotification = 10711,          
        SRQSOpenNegotiationRequest = 10700,               
        SRQSOpenNegotiationRequesterNotification = 10710, 
        SRQSQuoteNotification = 10707,                    
        SRQSQuoteResponse = 10703,                        
        SRQSQuoteSnapshotNotification = 10723,            
        SRQSQuoteSnapshotRequest = 10720,                 
        SRQSQuotingStatusRequest = 10717,                 
        SRQSResponse = 10722,                             
        SRQSStatusBroadcast = 10714,                      
        SRQSUpdateDealStatusRequest = 10706,              
        SRQSUpdateNegotiationRequest = 10701,             
        ServiceAvailabilityBroadcast = 10030,             
        ServiceAvailabilityMarketBroadcast = 10044,       
        StatusBroadcast = 10045,                          
        SubscribeRequest = 10025,                         
        SubscribeResponse = 10005,                        
        TESApproveBroadcast = 10607,                      
        TESBroadcast = 10604,                             
        TESDeleteBroadcast = 10606,                       
        TESExecutionBroadcast = 10610,                    
        TESInquireBoundaryPricesRequest = 10329,          
        TESInquireBoundaryPricesResponse = 10330,         
        TESResponse = 10611,                              
        TESReversalBroadcast = 10632,                     
        TESTradeBroadcast = 10614,                        
        TESTradingSessionStatusBroadcast = 10615,         
        TESUploadBroadcast = 10613,                       
        TMTradingSessionStatusBroadcast = 10501,          
        ThrottleUpdateNotification = 10028,               
        TradeBroadcast = 10500,                           
        TradingActionRequest = 10904,                     
        TradingActionResponse = 10905,                    
        TradingSessionStatusBroadcast = 10307,            
        UnsubscribeRequest = 10006,                       
        UnsubscribeResponse = 10007,                      
        UpdateReferencePriceRequest = 10331,              
        UpdateReferencePricesResponse = 10332,            
        UpdateRemainingRiskAllowanceBaseRequest = 10325,  
        UpdateRemainingRiskAllowanceBaseResponse = 10326, 
        UploadTESTradeRequest = 10612,                    
        UserLoginRequest = 10018,                         
        UserLoginRequestEncrypted = 19018,                
        UserLoginResponse = 10019,                        
        UserLogoutRequest = 10029,                        
        UserLogoutResponse = 10024                        
    };
};

ONIXS_EUREX_ETI_EXPORT std::string enumToString(TemplateId::Enum);

ONIXS_EUREX_ETI_EXPORT std::ostream& operator<<(std::ostream&, TemplateId::Enum);
 
}}} // namespace OnixS::Eurex::Trading