Fields.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/Euronext/MarketData/OptiqMdg/messaging/StrRef.h>
#include <OnixS/Euronext/MarketData/OptiqMdg/messaging/Integral.h>

ONIXS_EURONEXT_OPTIQMDG_MESSAGING_NAMESPACE_BEGIN

/// Type alias for the `Unsigned_char`.
typedef UInt8 UnsignedChar;


/// Type alias for the `Int8_t`.
typedef Int8 Int8;


/// Type alias for the `Uint16_t`.
typedef UInt16 Uint16;


/// Type alias for the `Uint32_t`.
typedef UInt32 Uint32;


/// Type alias for the `Uint64_t`.
typedef UInt64 Uint64;


/// Type alias for the `Int32_t`.
typedef Int32 Int32;


/// Type alias for the `Int64_t`.
typedef Int64 Int64;


/// Type alias for the `Time_t`.
typedef UInt64 Time;


/// Type alias for the `Char1`.
typedef Char Char1;


/// Type alias for the `Char2`.
typedef Char Char2[2];


/// Type alias for the `Char3`.
typedef Char Char3[3];


/// Type alias for the `Char4`.
typedef Char Char4[4];


/// Type alias for the `Char5`.
typedef Char Char5[5];


/// Type alias for the `Char6`.
typedef Char Char6[6];


/// Type alias for the `Char7`.
typedef Char Char7[7];


/// Type alias for the `Char8`.
typedef Char Char8[8];


/// Type alias for the `Char10`.
typedef Char Char10[10];


/// Type alias for the `Char11`.
typedef Char Char11[11];


/// Type alias for the `Char12`.
typedef Char Char12[12];


/// Type alias for the `Char13`.
typedef Char Char13[13];


/// Type alias for the `Char15`.
typedef Char Char15[15];


/// Type alias for the `Char16`.
typedef Char Char16[16];


/// Type alias for the `Char18`.
typedef Char Char18[18];


/// Type alias for the `Char20`.
typedef Char Char20[20];


/// Type alias for the `Char24`.
typedef Char Char24[24];


/// Type alias for the `Char25`.
typedef Char Char25[25];


/// Type alias for the `Char27`.
typedef Char Char27[27];


/// Type alias for the `Char30`.
typedef Char Char30[30];


/// Type alias for the `Char32`.
typedef Char Char32[32];


/// Type alias for the `Char50`.
typedef Char Char50[50];


/// Type alias for the `Char52`.
typedef Char Char52[52];


/// Type alias for the `Char60`.
typedef Char Char60[60];


/// Type alias for the `Char100`.
typedef Char Char100[100];


/// Type alias for the `Char102`.
typedef Char Char102[102];


/// Type alias for the `Char250`.
typedef Char Char250[250];


/// `PricingAlgorithm_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT PricingAlgorithm
{
    typedef UInt8 Base;

    enum Enum
    {
        /// Standard
        Standard = 0,

        /// TotalReturnFuture
        TotalReturnFuture = 1,

        /// MarketOnClose
        MarketOnClose = 2
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `AccountType_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT AccountType
{
    typedef UInt8 Base;

    enum Enum
    {
        /// Client
        Client = 1,

        /// House
        House = 2,

        /// RO
        RO = 4,

        /// AssignedBroker
        AssignedBroker = 5,

        /// LiquidityProvider
        LiquidityProvider = 6,

        /// RelatedParty
        RelatedParty = 7,

        /// StructuredProductMarketMaker
        StructuredProductMarketMaker = 8,

        /// OmegaClient
        OmegaClient = 14,

        /// CeresClient
        CeresClient = 15
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `Session_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT Session
{
    typedef UInt8 Base;

    enum Enum
    {
        /// Session0
        Session0 = 0,

        /// Session1
        Session1 = 1,

        /// Session2
        Session2 = 2,

        /// Session3
        Session3 = 3,

        /// Session4
        Session4 = 4,

        /// Session5
        Session5 = 5,

        /// Session6
        Session6 = 6,

        /// Session7
        Session7 = 7,

        /// Session8
        Session8 = 8,

        /// Session9
        Session9 = 9
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `TechnicalNotificationType_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT TechnicalNotificationType
{
    typedef UInt8 Base;

    enum Enum
    {
        /// InstrumentBookRetransmissionEnd
        InstrumentBookRetransmissionEnd = 1,

        /// TradeRetransmissionStart
        TradeRetransmissionStart = 10,

        /// TradeRetransmissionEnd
        TradeRetransmissionEnd = 11
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `ScheduledEvent_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT ScheduledEvent
{
    typedef UInt8 Base;

    enum Enum
    {
        /// CancelPreviouslyScheduledEvent
        CancelPreviouslyScheduledEvent = 0,

        /// Reopening
        Reopening = 1,

        /// ResumptionOfTrading
        ResumptionOfTrading = 3,

        /// Closed
        Closed = 4,

        /// Expiry
        Expiry = 5,

        /// WholesaleLargeInScaleLiSTradesOpenExtension
        WholesaleLargeInScaleLiSTradesOpenExtension = 6,

        /// WholesaleBasisTradesOpenExtension
        WholesaleBasisTradesOpenExtension = 7,

        /// WholesaleAgainstActualsTradesOpenExtension
        WholesaleAgainstActualsTradesOpenExtension = 8,

        /// WholesaleLargeInScaleLiSPackageTradesOpenExtension
        WholesaleLargeInScaleLiSPackageTradesOpenExtension = 9,

        /// WholesaleExchangeForSwapsTradesOpenExtension
        WholesaleExchangeForSwapsTradesOpenExtension = 10,

        /// WholesaleTradesOpenExtension
        WholesaleTradesOpenExtension = 11,

        /// Suspension
        Suspension = 12,

        /// CollarsNormal
        CollarsNormal = 13,

        /// CollarsWide
        CollarsWide = 14,

        /// PreExpiry
        PreExpiry = 15,

        /// ClosingPrice
        ClosingPrice = 16
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `StatusReason_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT StatusReason
{
    typedef UInt8 Base;

    enum Enum
    {
        /// Scheduled
        Scheduled = 0,

        /// CollarsBreach
        CollarsBreach = 4,

        /// AutomaticReopening
        AutomaticReopening = 7,

        /// NoLiquidityProvider
        NoLiquidityProvider = 8,

        /// KnockInByIssuer
        KnockInByIssuer = 11,

        /// KnockOutByExchange
        KnockOutByExchange = 12,

        /// KnockOutByIssuer
        KnockOutByIssuer = 13,

        /// ActionByMarketOperations
        ActionByMarketOperations = 15,

        /// WaitingForTradableState
        WaitingForTradableState = 16,

        /// NewListing
        NewListing = 20,

        /// DueToUnderlying
        DueToUnderlying = 21,

        /// OutsideOfLPQuotes
        OutsideOfLPQuotes = 22,

        /// Technical
        Technical = 23,

        /// DueToLeg
        DueToLeg = 24,

        /// DueToMainMarket
        DueToMainMarket = 25
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `ImbalanceQuantitySide_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT ImbalanceQuantitySide
{
    typedef UInt8 Base;

    enum Enum
    {
        /// NoImbalance
        NoImbalance = 0,

        /// Buy
        Buy = 1,

        /// Sell
        Sell = 2
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `InstrumentCategory_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT InstrumentCategory
{
    typedef UInt8 Base;

    enum Enum
    {
        /// Equities
        Equities = 1,

        /// FixedIncome
        FixedIncome = 2,

        /// WarrantsAndCertificates
        WarrantsAndCertificates = 3,

        /// Trackers
        Trackers = 6,

        /// Futures
        Futures = 7,

        /// Options
        Options = 10,

        /// Indices
        Indices = 11,

        /// EuronextFundsServices
        EuronextFundsServices = 12,

        /// INAVIndicativeNetAssetValue
        INAVIndicativeNetAssetValue = 14,

        /// Fund
        Fund = 15,

        /// Forex
        Forex = 16,

        /// Miscellaneous
        Miscellaneous = 254
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `InstrumentUnitExpression_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT InstrumentUnitExpression
{
    typedef UInt8 Base;

    enum Enum
    {
        /// Units
        Units = 1,

        /// PercentageOfNominalExcludingAccruedInterestClean
        PercentageOfNominalExcludingAccruedInterestClean = 2,

        /// BasisPoints
        BasisPoints = 3,

        /// PercentageMixed
        PercentageMixed = 4,

        /// PercentageOfNominalIncludingAccruedInterestDirty
        PercentageOfNominalIncludingAccruedInterestDirty = 5,

        /// Yield
        Yield = 7,

        /// Kilograms
        Kilograms = 8,

        /// Ounces
        Ounces = 9
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `RepoIndicator_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT RepoIndicator
{
    typedef UInt8 Base;

    enum Enum
    {
        /// InstrNeitherEligibleForSRDOrLoanAndLendingMkt
        InstrNeitherEligibleForSRDOrLoanAndLendingMkt = 0,

        /// InstrEligibleForSRDAndForLoanAndLendingMarket
        InstrEligibleForSRDAndForLoanAndLendingMarket = 1,

        /// InstrEligibleForTheSRDLongOnly
        InstrEligibleForTheSRDLongOnly = 2,

        /// InstrEligibleForLoanAndLendingMktAndForSRDLongOnly
        InstrEligibleForLoanAndLendingMktAndForSRDLongOnly = 3,

        /// EasytoborrowInstrEligibleForSRDAndForLoanAndLendingMkt
        EasytoborrowInstrEligibleForSRDAndForLoanAndLendingMkt = 4,

        /// InstrEligibleForTheLoanAndLendingMarket
        InstrEligibleForTheLoanAndLendingMarket = 5,

        /// NonSignificant
        NonSignificant = 8
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `StrikeCurrencyIndicator_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT StrikeCurrencyIndicator
{
    typedef UInt8 Base;

    enum Enum
    {
        /// ChangeRateNotAppliedToTheStrikePrice
        ChangeRateNotAppliedToTheStrikePrice = 0,

        /// ChangeRateAppliedToTheStrikePrice
        ChangeRateAppliedToTheStrikePrice = 1
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `TradingCurrencyIndicator_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT TradingCurrencyIndicator
{
    typedef UInt8 Base;

    enum Enum
    {
        /// ChangeRateNotAppliedToTheTradedPrice
        ChangeRateNotAppliedToTheTradedPrice = 0,

        /// ChangeRateAppliedToTheTradedPrice
        ChangeRateAppliedToTheTradedPrice = 1
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `ContractType_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT ContractType
{
    typedef Char Base;

    enum Enum
    {
        /// Future
        Future = 'F',

        /// Option
        Option = 'O',

        /// Underlying
        Underlying = 'U'
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `ExpiryCycleType_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT ExpiryCycleType
{
    typedef UInt8 Base;

    enum Enum
    {
        /// Daily
        Daily = 1,

        /// Weekly
        Weekly = 2,

        /// Monthly
        Monthly = 3
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `MessagePriceNotation_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT MessagePriceNotation
{
    typedef UInt8 Base;

    enum Enum
    {
        /// Price
        Price = 1,

        /// SpreadInBasisPoints
        SpreadInBasisPoints = 2,

        /// Spread
        Spread = 3
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `UnderlyingType_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT UnderlyingType
{
    typedef Char Base;

    enum Enum
    {
        /// BasketWithCommodity
        BasketWithCommodity = 'A',

        /// Basket
        Basket = 'B',

        /// Commodity
        Commodity = 'C',

        /// DepositaryReceipt
        DepositaryReceipt = 'D',

        /// Future
        Future = 'F',

        /// CurrencyLeveragedIndex
        CurrencyLeveragedIndex = 'G',

        /// Other
        Other = 'H',

        /// Index
        Index = 'I',

        /// Bonds
        Bonds = 'J',

        /// StockDividend
        StockDividend = 'K',

        /// LeveragedIndex
        LeveragedIndex = 'L',

        /// InterestRate
        InterestRate = 'N',

        /// OtherDerivative
        OtherDerivative = 'O',

        /// CommodityIndex
        CommodityIndex = 'P',

        /// CommodityLeveragedIndex
        CommodityLeveragedIndex = 'Q',

        /// Right
        Right = 'R',

        /// Stock
        Stock = 'S',

        /// Credit
        Credit = 'T',

        /// Fund
        Fund = 'U',

        /// Currency
        Currency = 'V',

        /// StockWarrant
        StockWarrant = 'W',

        /// ExchangeRate
        ExchangeRate = 'X',

        /// SecurityLeveragedIndex
        SecurityLeveragedIndex = 'Z'
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `StrategyCode_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT StrategyCode
{
    typedef Char Base;

    enum Enum
    {
        /// JellyRoll
        JellyRoll = 'A',

        /// Butterfly
        Butterfly = 'B',

        /// CallOrPutCabinet
        CallOrPutCabinet = 'C',

        /// Spread
        Spread = 'D',

        /// CalendarSpread
        CalendarSpread = 'E',

        /// DiagonalCalendarSpread
        DiagonalCalendarSpread = 'F',

        /// Guts
        Guts = 'G',

        /// TwoByOneRatioSpread
        TwoByOneRatioSpread = 'H',

        /// IronButterfly
        IronButterfly = 'I',

        /// Combo
        Combo = 'J',

        /// Strangle
        Strangle = 'K',

        /// Ladder
        Ladder = 'L',

        /// Strip
        Strip = 'M',

        /// StraddleCalendarSpread
        StraddleCalendarSpread = 'N',

        /// Pack
        Pack = 'O',

        /// DiagonalStraddleCalendarSpread
        DiagonalStraddleCalendarSpread = 'P',

        /// SimpleInterCommoditySpread
        SimpleInterCommoditySpread = 'Q',

        /// ConversionReversal
        ConversionReversal = 'R',

        /// Straddle
        Straddle = 'S',

        /// VolatilityTrade
        VolatilityTrade = 'V',

        /// Condor
        Condor = 'W',

        /// Box
        Box = 'X',

        /// Bundle
        Bundle = 'Y',

        /// ReducedTickSpread
        ReducedTickSpread = 'Z',

        /// LadderVersusUnderlying
        LadderVersusUnderlying = 'a',

        /// ButterflyVersusUnderlying
        ButterflyVersusUnderlying = 'b',

        /// CallSpreadVersusPutVersusUnderlying
        CallSpreadVersusPutVersusUnderlying = 'c',

        /// CallOrPutSpreadVersusUnderlying
        CallOrPutSpreadVersusUnderlying = 'd',

        /// CallOrPutCalendarSpreadVersusUnderlying
        CallOrPutCalendarSpreadVersusUnderlying = 'e',

        /// CallPutDiagonalCalendarSpreadVersusUnderlying
        CallPutDiagonalCalendarSpreadVersusUnderlying = 'f',

        /// GutsVersusUnderlying
        GutsVersusUnderlying = 'g',

        /// TwoByOneCallOrPutRatioSpreadVersusUnderlying
        TwoByOneCallOrPutRatioSpreadVersusUnderlying = 'h',

        /// IronButterflyVersusUnderlying
        IronButterflyVersusUnderlying = 'i',

        /// ComboVersusUnderlying
        ComboVersusUnderlying = 'j',

        /// StrangleVersusUnderlying
        StrangleVersusUnderlying = 'k',

        /// ExchangeForPhysical
        ExchangeForPhysical = 'm',

        /// StraddleCalendarSpreadVersusUnderlying
        StraddleCalendarSpreadVersusUnderlying = 'n',

        /// PutSpreadVersusCallVersusUnderlying
        PutSpreadVersusCallVersusUnderlying = 'p',

        /// DiagonalStraddleCalendarSpreadVersusUnderlying
        DiagonalStraddleCalendarSpreadVersusUnderlying = 'q',

        /// Synthetic
        Synthetic = 'r',

        /// StraddleVersusUnderlying
        StraddleVersusUnderlying = 's',

        /// CondorVersusUnderlying
        CondorVersusUnderlying = 't',

        /// BuyWrite
        BuyWrite = 'u',

        /// IronCondorVersusUnderlying
        IronCondorVersusUnderlying = 'v',

        /// IronCondor
        IronCondor = 'w',

        /// CallSpreadVersusSellAPut
        CallSpreadVersusSellAPut = 'x',

        /// PutSpreadVersusSellACall
        PutSpreadVersusSellACall = 'y',

        /// PutStraddleVersusSellACallOrAPut
        PutStraddleVersusSellACallOrAPut = 'z'
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `MarketDataActionType_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT MarketDataActionType
{
    typedef UInt8 Base;

    enum Enum
    {
        /// NewOrder
        NewOrder = 1,

        /// DeletionOfIdentifiedOrder
        DeletionOfIdentifiedOrder = 2,

        /// DeletionOfAllOrdersBySide
        DeletionOfAllOrdersBySide = 3,

        /// ModificationOfExistingOrderWithoutLossOfPriority
        ModificationOfExistingOrderWithoutLossOfPriority = 4,

        /// RetransmissionOfAllOrders
        RetransmissionOfAllOrders = 5,

        /// ModificationOfExistingOrderWithLossOfPriority
        ModificationOfExistingOrderWithLossOfPriority = 6,

        /// RFQAnswerCreation
        RFQAnswerCreation = 7,

        /// RFQAnswerDeletion
        RFQAnswerDeletion = 8
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `MarketDataPriceType_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT MarketDataPriceType
{
    typedef UInt8 Base;

    enum Enum
    {
        /// OfficialDaily
        OfficialDaily = 2,

        /// OfficialMarketClose
        OfficialMarketClose = 4,

        /// OfficialExpiry
        OfficialExpiry = 6,

        /// ProvisionalIntraday
        ProvisionalIntraday = 7,

        /// OfficialIntraday
        OfficialIntraday = 8,

        /// OfficialYDSP
        OfficialYDSP = 9,

        /// NAVForTheInstrumentsEligibleToTheNAVTradingFacility
        NAVForTheInstrumentsEligibleToTheNAVTradingFacility = 10,

        /// AdjustedClosingPrice
        AdjustedClosingPrice = 12,

        /// SubscriptionPrice
        SubscriptionPrice = 13,

        /// IndicativeMatchingPrice
        IndicativeMatchingPrice = 14,

        /// MinPriceOutOfSessionTrades
        MinPriceOutOfSessionTrades = 19,

        /// MaxPriceOutOfSessionTrades
        MaxPriceOutOfSessionTrades = 20,

        /// MinPriceOutOfSessionBlockTrades
        MinPriceOutOfSessionBlockTrades = 21,

        /// MaxPriceOutOfSessionBlockTrades
        MaxPriceOutOfSessionBlockTrades = 22,

        /// ValuationPrice
        ValuationPrice = 23,

        /// FundSubscription
        FundSubscription = 24,

        /// FundRedemption
        FundRedemption = 25,

        /// UncrossingPrice
        UncrossingPrice = 26,

        /// LastTradedPrice
        LastTradedPrice = 27,

        /// AIP
        AIP = 28,

        /// NetAssetValue
        NetAssetValue = 30,

        /// ExternalReferencePrice
        ExternalReferencePrice = 31,

        /// ClosingPrice
        ClosingPrice = 33
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `UnderlyingSubtype_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT UnderlyingSubtype
{
    typedef UInt8 Base;

    enum Enum
    {
        /// Basket
        Basket = 0,

        /// Dividend
        Dividend = 1,

        /// ETF
        ETF = 2,

        /// Share
        Share = 3,

        /// DividendIndex
        DividendIndex = 4,

        /// EquityIndex
        EquityIndex = 5,

        /// TRFIndex
        TRFIndex = 6,

        /// VolatilityIndex
        VolatilityIndex = 7,

        /// FutureOnCommodities
        FutureOnCommodities = 8,

        /// FXCrossRates
        FXCrossRates = 9,

        /// FXEmergingMarkets
        FXEmergingMarkets = 10,

        /// FXMajors
        FXMajors = 11,

        /// Agricultural
        Agricultural = 12,

        /// Environmental
        Environmental = 13,

        /// Freight
        Freight = 14,

        /// Fertilizer
        Fertilizer = 15,

        /// IndustrialProducts
        IndustrialProducts = 16,

        /// Inflation
        Inflation = 17,

        /// MultiCommodityExotic
        MultiCommodityExotic = 18,

        /// Metals
        Metals = 19,

        /// Energy
        Energy = 20,

        /// OfficialEconomicStatistics
        OfficialEconomicStatistics = 21,

        /// OtherC10
        OtherC10 = 22,

        /// Other
        Other = 23,

        /// Paper
        Paper = 24,

        /// Polypropylene
        Polypropylene = 25
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `QuoteUpdateType_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT QuoteUpdateType
{
    typedef UInt8 Base;

    enum Enum
    {
        /// BestBid
        BestBid = 1,

        /// BestOffer
        BestOffer = 2,

        /// CancelBid
        CancelBid = 5,

        /// CancelOffer
        CancelOffer = 6
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `MarketDataUpdateType_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT MarketDataUpdateType
{
    typedef UInt8 Base;

    enum Enum
    {
        /// BestBid
        BestBid = 1,

        /// BestOffer
        BestOffer = 2,

        /// NewBid
        NewBid = 3,

        /// NewOffer
        NewOffer = 4,

        /// UpdatedBid
        UpdatedBid = 5,

        /// UpdatedOffer
        UpdatedOffer = 6,

        /// TotalTradedVolume
        TotalTradedVolume = 7,

        /// ImpliedBid
        ImpliedBid = 8,

        /// ImpliedOffer
        ImpliedOffer = 9,

        /// RequestForQuote
        RequestForQuote = 10,

        /// RequestForQuoteBid
        RequestForQuoteBid = 11,

        /// RequestForSize
        RequestForSize = 12,

        /// RequestForQuoteOffer
        RequestForQuoteOffer = 13,

        /// HighDynamicCollar
        HighDynamicCollar = 14,

        /// LowDynamicCollar
        LowDynamicCollar = 15,

        /// NewBidRLP
        NewBidRLP = 16,

        /// NewOfferRLP
        NewOfferRLP = 17,

        /// UpdatedBidRLP
        UpdatedBidRLP = 18,

        /// UpdatedOfferRLP
        UpdatedOfferRLP = 19,

        /// ConventionalTrade
        ConventionalTrade = 24,

        /// RequestForCrossRFCQueued
        RequestForCrossRFCQueued = 25,

        /// RequestForCrossRFC
        RequestForCrossRFC = 26,

        /// LargeInScaleLiSTrade
        LargeInScaleLiSTrade = 27,

        /// BasisTrade
        BasisTrade = 28,

        /// LargeInScaleLiSPackageTrade
        LargeInScaleLiSPackageTrade = 29,

        /// GuaranteedCrossTrade
        GuaranteedCrossTrade = 30,

        /// AgainstActualTrade
        AgainstActualTrade = 31,

        /// AssetAllocationTrade
        AssetAllocationTrade = 32,

        /// ExchangeForSwapTrade
        ExchangeForSwapTrade = 34,

        /// DarkTrade
        DarkTrade = 35,

        /// ExchangeForPhysicalTradeCashLeg
        ExchangeForPhysicalTradeCashLeg = 36,

        /// StrategyLegConventionalTrade
        StrategyLegConventionalTrade = 37,

        /// StrategyLegLargeInScaleLiSTrade
        StrategyLegLargeInScaleLiSTrade = 38,

        /// StrategyLegBasisTrade
        StrategyLegBasisTrade = 39,

        /// StrategyLegGuaranteedCrossTrade
        StrategyLegGuaranteedCrossTrade = 40,

        /// StrategyLegAgainstActualTrade
        StrategyLegAgainstActualTrade = 41,

        /// StrategyLegAssetAllocationTrade
        StrategyLegAssetAllocationTrade = 42,

        /// StrategyLegExchangeForSwapTrade
        StrategyLegExchangeForSwapTrade = 44,

        /// StrategyLegExchangeForPhysicalTrade
        StrategyLegExchangeForPhysicalTrade = 45,

        /// BoBTrade
        BoBTrade = 46,

        /// AtomXTrade
        AtomXTrade = 48,

        /// TradeCancellation
        TradeCancellation = 50,

        /// OutOfMarketTrade
        OutOfMarketTrade = 51,

        /// DeltaNeutralTradeUnderlyingCashLeg
        DeltaNeutralTradeUnderlyingCashLeg = 52,

        /// DeltaNeutralTradeUnderlyingFutureLeg
        DeltaNeutralTradeUnderlyingFutureLeg = 53,

        /// EuronextFundServiceTrade
        EuronextFundServiceTrade = 54,

        /// SecondaryListingTrade
        SecondaryListingTrade = 55,

        /// RequestForCrossTrade
        RequestForCrossTrade = 56,

        /// RequestForCrossStrategyLegTrade
        RequestForCrossStrategyLegTrade = 57,

        /// NewBidWithLiquidityProvider
        NewBidWithLiquidityProvider = 58,

        /// NewOfferWithLiquidityProvider
        NewOfferWithLiquidityProvider = 59,

        /// UpdatedBidWithLiquidityProvider
        UpdatedBidWithLiquidityProvider = 60,

        /// UpdatedOfferWithLiquidityProvider
        UpdatedOfferWithLiquidityProvider = 61,

        /// LowStaticCollar
        LowStaticCollar = 63,

        /// HighStaticCollar
        HighStaticCollar = 64,

        /// MarketVWAPOperationTrade
        MarketVWAPOperationTrade = 65,

        /// RequestForSizeBid
        RequestForSizeBid = 66,

        /// RequestForSizeOffer
        RequestForSizeOffer = 67,

        /// LowLPCollar
        LowLPCollar = 70,

        /// HighLPCollar
        HighLPCollar = 71,

        /// ETFMTFNAVTradePriceInBp
        ETFMTFNAVTradePriceInBp = 72,

        /// ETFMTFNAVDarkTradePriceInBp
        ETFMTFNAVDarkTradePriceInBp = 73,

        /// NewBidOnWholesaleRFC
        NewBidOnWholesaleRFC = 74,

        /// NewOfferOnWholesaleRFC
        NewOfferOnWholesaleRFC = 75,

        /// UpdatedBidOnWholesaleRFC
        UpdatedBidOnWholesaleRFC = 76,

        /// UpdatedOfferOnWholesaleRFC
        UpdatedOfferOnWholesaleRFC = 77,

        /// ClearWholesaleRFC
        ClearWholesaleRFC = 78,

        /// GuaranteedCrossNegotiatedDealNLIQ
        GuaranteedCrossNegotiatedDealNLIQ = 79,

        /// GuaranteedCrossNegotiatedDealOILQ
        GuaranteedCrossNegotiatedDealOILQ = 80,

        /// LargeInScaleTrade
        LargeInScaleTrade = 81,

        /// LargeInScaleTradeInBasisPoints
        LargeInScaleTradeInBasisPoints = 82,

        /// LargeInScalePackageTradeInBasisPoints
        LargeInScalePackageTradeInBasisPoints = 83,

        /// StrategyLegLargeInScaleTradeInBasisPoints
        StrategyLegLargeInScaleTradeInBasisPoints = 84,

        /// NewBidRFQAnswer
        NewBidRFQAnswer = 86,

        /// NewOfferRFQAnswer
        NewOfferRFQAnswer = 87,

        /// UpdatedBidRFQAnswer
        UpdatedBidRFQAnswer = 88,

        /// UpdatedOfferRFQAnswer
        UpdatedOfferRFQAnswer = 89,

        /// BidExecutionSummary
        BidExecutionSummary = 90,

        /// AQSExpansionFactor
        AQSExpansionFactor = 91,

        /// CollarsExpansionFactor
        CollarsExpansionFactor = 92,

        /// CollarsEnabled
        CollarsEnabled = 93,

        /// CollarsDisabled
        CollarsDisabled = 94,

        /// DCRPInterMonthSpread
        DCRPInterMonthSpread = 95,

        /// FSPReferencePrice
        FSPReferencePrice = 96,

        /// OfferExecutionSummary
        OfferExecutionSummary = 97,

        /// FSPTriggered
        FSPTriggered = 98,

        /// MidPointBBO
        MidPointBBO = 99,

        /// ConventionalTradeProvisionalPrice
        ConventionalTradeProvisionalPrice = 100,

        /// HighOrderPriceControlCollar
        HighOrderPriceControlCollar = 101,

        /// LowOrderPriceControlCollar
        LowOrderPriceControlCollar = 102,

        /// OrderPriceControlCollarReferencePrice
        OrderPriceControlCollarReferencePrice = 103,

        /// IssuingOrTenderOfferTrade
        IssuingOrTenderOfferTrade = 104,

        /// RFQTrade
        RFQTrade = 105,

        /// FLIPSpread
        FLIPSpread = 106,

        /// FLIPReferencePrice
        FLIPReferencePrice = 107,

        /// ClearBook
        ClearBook = 254
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `MarketDataChangeType_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT MarketDataChangeType
{
    typedef UInt8 Base;

    enum Enum
    {
        /// StatusChanges
        StatusChanges = 0,

        /// ScheduledEventNotification
        ScheduledEventNotification = 1,

        /// StatusChangeAndScheduledEventNotification
        StatusChangeAndScheduledEventNotification = 2
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `EMM_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT Emm
{
    typedef UInt8 Base;

    enum Enum
    {
        /// CashAndDerivativeCentralOrderBook
        CashAndDerivativeCentralOrderBook = 1,

        /// NAVTradingFacility
        NAVTradingFacility = 2,

        /// DerivativesWholesales
        DerivativesWholesales = 4,

        /// CashOnExchangeOffBook
        CashOnExchangeOffBook = 5,

        /// EuronextOffExchangeTradeReports
        EuronextOffExchangeTradeReports = 6,

        /// DerivativesOnExchangeOffBook
        DerivativesOnExchangeOffBook = 7,

        /// ETFMTFNAVCentralOrderBook
        ETFMTFNAVCentralOrderBook = 8,

        /// ListedNotTraded
        ListedNotTraded = 9,

        /// DeltaNeutralContingencyLeg
        DeltaNeutralContingencyLeg = 15,

        /// NotApplicable
        NotApplicable = 99
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `MarketModel_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT MarketModel
{
    typedef UInt8 Base;

    enum Enum
    {
        /// OrderDriven
        OrderDriven = 1,

        /// QuoteDriven
        QuoteDriven = 2,

        /// IPO
        IPO = 3,

        /// PrimaryMarket
        PrimaryMarket = 4,

        /// RFQ
        RFQ = 5,

        /// ConditionalUncrossing
        ConditionalUncrossing = 6
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `OrderEntryQualifier_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT OrderEntryQualifier
{
    typedef UInt8 Base;

    enum Enum
    {
        /// OrderEntryCancelModifyDisabled
        OrderEntryCancelModifyDisabled = 0,

        /// OrderEntryCancelModifyEnabled
        OrderEntryCancelModifyEnabled = 1,

        /// CancelAndModifyOnly
        CancelAndModifyOnly = 2,

        /// CancelOnly
        CancelOnly = 3
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `OrderSide_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT OrderSide
{
    typedef UInt8 Base;

    enum Enum
    {
        /// Buy
        Buy = 1,

        /// Sell
        Sell = 2,

        /// Cross
        Cross = 3
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `OrderType_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT OrderType
{
    typedef UInt8 Base;

    enum Enum
    {
        /// Market
        Market = 1,

        /// Limit
        Limit = 2,

        /// StopMarketOrStopMarketOnQuote
        StopMarketOrStopMarketOnQuote = 3,

        /// StopLimitOrStopLimitOnQuote
        StopLimitOrStopLimitOnQuote = 4,

        /// PrimaryPeg
        PrimaryPeg = 5,

        /// MarketToLimit
        MarketToLimit = 6,

        /// MarketPeg
        MarketPeg = 7,

        /// MidPointPeg
        MidPointPeg = 8,

        /// AveragePrice
        AveragePrice = 9,

        /// Iceberg
        Iceberg = 10
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `BookState_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT BookState
{
    typedef UInt8 Base;

    enum Enum
    {
        /// Inaccessible
        Inaccessible = 1,

        /// Closed
        Closed = 2,

        /// Call
        Call = 3,

        /// Uncrossing
        Uncrossing = 4,

        /// Continuous
        Continuous = 5,

        /// Halted
        Halted = 6,

        /// ContinuousUncrossing
        ContinuousUncrossing = 7,

        /// Suspended
        Suspended = 8,

        /// Reserved
        Reserved = 9
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `PhaseId_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT PhaseId
{
    typedef UInt8 Base;

    enum Enum
    {
        /// Inaccessible
        Inaccessible = 1,

        /// Closed
        Closed = 2,

        /// Call
        Call = 3,

        /// Uncrossing
        Uncrossing = 4,

        /// Continuous
        Continuous = 5,

        /// ContinuousUncrossing
        ContinuousUncrossing = 7
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `InstrumentState_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT InstrumentState
{
    typedef UInt8 Base;

    enum Enum
    {
        /// Scheduled
        Scheduled = 1,

        /// SuspendedDueToUnderlying
        SuspendedDueToUnderlying = 2,

        /// SuspendedKOBI
        SuspendedKOBI = 3,

        /// SuspendedKOBE
        SuspendedKOBE = 4,

        /// SuspendedNewListing
        SuspendedNewListing = 5,

        /// SuspendedByMO
        SuspendedByMO = 6,

        /// SuspendedTechnical
        SuspendedTechnical = 7,

        /// ReservedDynamicCollars
        ReservedDynamicCollars = 8,

        /// ReservedStaticCollars
        ReservedStaticCollars = 9,

        /// ReservedWaitingForLP
        ReservedWaitingForLP = 10,

        /// ReservedLPLimit
        ReservedLPLimit = 11,

        /// InstrumentDeletion
        InstrumentDeletion = 12,

        /// SuspendedWaitingForBBO
        SuspendedWaitingForBBO = 13,

        /// SuspendedWaitingForTradableState
        SuspendedWaitingForTradableState = 14,

        /// RandomUncrossingPeriod
        RandomUncrossingPeriod = 15,

        /// Expired
        Expired = 16,

        /// Uncrossing
        Uncrossing = 17,

        /// ReservedDueToLeg
        ReservedDueToLeg = 18,

        /// SuspendedDueToLeg
        SuspendedDueToLeg = 19,

        /// ReservedFutureLimitInterruptionProtection
        ReservedFutureLimitInterruptionProtection = 21,

        /// SuspendedWaitingForMarketOperations
        SuspendedWaitingForMarketOperations = 22
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `TradeType_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT TradeType
{
    typedef UInt8 Base;

    enum Enum
    {
        /// ConventionalTrade
        ConventionalTrade = 1,

        /// LargeInScaleLiSTrade
        LargeInScaleLiSTrade = 2,

        /// BasisTrade
        BasisTrade = 3,

        /// LargeInScaleLiSPackageTrade
        LargeInScaleLiSPackageTrade = 4,

        /// GuaranteedCrossTrade
        GuaranteedCrossTrade = 5,

        /// AgainstActualTrade
        AgainstActualTrade = 6,

        /// AssetAllocationTrade
        AssetAllocationTrade = 7,

        /// ExchangeForSwapTrade
        ExchangeForSwapTrade = 9,

        /// ExchangeForPhysicalTradeCashLeg
        ExchangeForPhysicalTradeCashLeg = 10,

        /// StrategyLegConventionalTrade
        StrategyLegConventionalTrade = 11,

        /// StrategyLegLargeInScaleLiSTrade
        StrategyLegLargeInScaleLiSTrade = 12,

        /// StrategyLegBasisTrade
        StrategyLegBasisTrade = 13,

        /// StrategyLegGuaranteedCrossTrade
        StrategyLegGuaranteedCrossTrade = 14,

        /// StrategyLegAgainstActualTrade
        StrategyLegAgainstActualTrade = 15,

        /// StrategyLegAssetAllocationTrade
        StrategyLegAssetAllocationTrade = 16,

        /// StrategyLegExchangeForSwapTrade
        StrategyLegExchangeForSwapTrade = 18,

        /// StrategyLegExchangeForPhysicalTrade
        StrategyLegExchangeForPhysicalTrade = 19,

        /// BoBTrade
        BoBTrade = 20,

        /// AtomXTrade
        AtomXTrade = 22,

        /// TradeCancellation
        TradeCancellation = 24,

        /// OutOfMarketTrade
        OutOfMarketTrade = 25,

        /// DeltaNeutralTradeUnderlyingCashLeg
        DeltaNeutralTradeUnderlyingCashLeg = 26,

        /// MarketVWAPOperationTrade
        MarketVWAPOperationTrade = 27,

        /// EuronextFundServiceTrade
        EuronextFundServiceTrade = 28,

        /// SecondaryListingTrade
        SecondaryListingTrade = 29,

        /// RequestForCrossTrade
        RequestForCrossTrade = 30,

        /// RequestForCrossStrategyLegTrade
        RequestForCrossStrategyLegTrade = 31,

        /// TradePublication
        TradePublication = 32,

        /// DarkTrade
        DarkTrade = 33,

        /// DeltaNeutralTradeUnderlyingFutureLeg
        DeltaNeutralTradeUnderlyingFutureLeg = 34,

        /// TotalTradedVolume
        TotalTradedVolume = 36,

        /// ETFMTFNAVTradePriceInBp
        ETFMTFNAVTradePriceInBp = 37,

        /// ETFMTFNAVDarkTradePriceInBp
        ETFMTFNAVDarkTradePriceInBp = 38,

        /// GuaranteedCrossNegotiatedDealNLIQ
        GuaranteedCrossNegotiatedDealNLIQ = 39,

        /// GuaranteedCrossNegotiatedDealOILQ
        GuaranteedCrossNegotiatedDealOILQ = 40,

        /// LargeInScaleTrade
        LargeInScaleTrade = 41,

        /// LargeInScaleTradeInBasisPoints
        LargeInScaleTradeInBasisPoints = 42,

        /// LargeInScalePackageTradeInBasisPoints
        LargeInScalePackageTradeInBasisPoints = 43,

        /// StrategyLegLargeInScaleTradeInBasisPoints
        StrategyLegLargeInScaleTradeInBasisPoints = 44,

        /// TradeReversal
        TradeReversal = 45,

        /// NonStandardSettlement
        NonStandardSettlement = 46,

        /// RepurchaseAgreementRepo
        RepurchaseAgreementRepo = 47,

        /// ExchangeGrantedTrade
        ExchangeGrantedTrade = 48,

        /// Other
        Other = 49,

        /// OddLot
        OddLot = 50,

        /// ConventionalTradeProvisionalPrice
        ConventionalTradeProvisionalPrice = 100,

        /// LargeInScaleLiSTradeProvisionalPrice
        LargeInScaleLiSTradeProvisionalPrice = 101,

        /// LargeInScaleLiSPackageTradeProvisionalPrice
        LargeInScaleLiSPackageTradeProvisionalPrice = 102,

        /// IssuingOrTenderOfferTrade
        IssuingOrTenderOfferTrade = 103,

        /// RFQTrade
        RFQTrade = 104
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `TradingPeriod_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT TradingPeriod
{
    typedef UInt8 Base;

    enum Enum
    {
        /// Opening
        Opening = 1,

        /// Standard
        Standard = 2,

        /// Closing
        Closing = 3
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `TradingSide_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT TradingSide
{
    typedef UInt8 Base;

    enum Enum
    {
        /// BidOnly
        BidOnly = 1,

        /// OfferOnly
        OfferOnly = 2,

        /// PAKO
        PAKO = 3,

        /// BothSides
        BothSides = 4
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `PriceLimits_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT PriceLimits
{
    typedef UInt8 Base;

    enum Enum
    {
        /// PriceLimitsEnabledNormal
        PriceLimitsEnabledNormal = 1,

        /// PriceLimitsEnabledWide
        PriceLimitsEnabledWide = 2,

        /// PriceLimitsEnabledWidest
        PriceLimitsEnabledWidest = 3,

        /// PriceLimitsDisabled
        PriceLimitsDisabled = 4
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `QuoteSpreadMultiplier_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT QuoteSpreadMultiplier
{
    typedef UInt8 Base;

    enum Enum
    {
        /// QuoteSpreadMultiplier1
        QuoteSpreadMultiplier1 = 1,

        /// QuoteSpreadMultiplier2
        QuoteSpreadMultiplier2 = 2,

        /// QuoteSpreadMultiplier3
        QuoteSpreadMultiplier3 = 3
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `ExchangeCode_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT ExchangeCode
{
    typedef Char Base;

    enum Enum
    {
        /// AmsterdamEquityDerivatives
        AmsterdamEquityDerivatives = 'A',

        /// BrusselsEquityDerivatives
        BrusselsEquityDerivatives = 'B',

        /// ParisEquityUnderlyings
        ParisEquityUnderlyings = 'C',

        /// BrusselsCashUnderlyings
        BrusselsCashUnderlyings = 'D',

        /// BrusselsIndexDerivatives
        BrusselsIndexDerivatives = 'F',

        /// AmsterdamCashUnderlyings
        AmsterdamCashUnderlyings = 'G',

        /// LisbonCashUnderlyings
        LisbonCashUnderlyings = 'H',

        /// ParisIndexDerivatives
        ParisIndexDerivatives = 'J',

        /// AmsterdamIndexDerivatives
        AmsterdamIndexDerivatives = 'K',

        /// LisbonIndexDerivatives
        LisbonIndexDerivatives = 'M',

        /// ParisEquityDerivatives
        ParisEquityDerivatives = 'P',

        /// AmsterdamCommoditiesDerivatives
        AmsterdamCommoditiesDerivatives = 'R',

        /// LisbonEquityDerivatives
        LisbonEquityDerivatives = 'S',

        /// ParisCommoditiesDerivatives
        ParisCommoditiesDerivatives = 'Y',

        /// AmsterdamCurrencyDerivatives
        AmsterdamCurrencyDerivatives = 'Z',

        /// OsloIndexDerivatives
        OsloIndexDerivatives = 'N',

        /// OsloEquityDerivatives
        OsloEquityDerivatives = 'O',

        /// OsloCashUnderlying
        OsloCashUnderlying = 'L',

        /// MilanCashUnderlying
        MilanCashUnderlying = 'U',

        /// MilanIndexDerivatives
        MilanIndexDerivatives = 'I',

        /// MilanEquityDerivatives
        MilanEquityDerivatives = 'E'
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `LegBuyorSell_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT LegBuyorSell
{
    typedef Char Base;

    enum Enum
    {
        /// Buy
        Buy = 'B',

        /// Sell
        Sell = 'S'
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `OptiqSegment_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT OptiqSegment
{
    typedef UInt8 Base;

    enum Enum
    {
        /// Equities
        Equities = 1,

        /// Funds
        Funds = 2,

        /// FixedIncome
        FixedIncome = 3,

        /// WarrantsAndCertificates
        WarrantsAndCertificates = 4,

        /// BourseDeLuxembourg
        BourseDeLuxembourg = 5,

        /// Options
        Options = 6,

        /// Futures
        Futures = 7,

        /// Commodities
        Commodities = 8,

        /// Indices
        Indices = 9,

        /// TradeReportingAndPublication
        TradeReportingAndPublication = 10,

        /// Block
        Block = 14,

        /// IndexDerivatives
        IndexDerivatives = 11,

        /// EquityDerivatives
        EquityDerivatives = 12,

        /// FinancialDerivatives
        FinancialDerivatives = 13,

        /// Forex
        Forex = 15,

        /// IBF
        IBF = 16
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `OptionType_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT OptionType
{
    typedef UInt8 Base;

    enum Enum
    {
        /// Call
        Call = 1,

        /// Put
        Put = 2,

        /// Other
        Other = 3
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `IndexLevelType_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT IndexLevelType
{
    typedef UInt8 Base;

    enum Enum
    {
        /// IndicativeIndex
        IndicativeIndex = 0,

        /// OfficialOpeningIndex
        OfficialOpeningIndex = 1,

        /// RealTimeIndex
        RealTimeIndex = 2,

        /// AutomaticIndicativeIndex
        AutomaticIndicativeIndex = 3,

        /// PreliminaryReferenceIndex
        PreliminaryReferenceIndex = 4,

        /// ClosingReferenceIndex
        ClosingReferenceIndex = 5,

        /// ConfirmedReferenceIndex
        ConfirmedReferenceIndex = 6,

        /// OptionsLiquidationIndex
        OptionsLiquidationIndex = 7
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `TransactionType_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT TransactionType
{
    typedef UInt8 Base;

    enum Enum
    {
        /// PlainVanillaTrade
        PlainVanillaTrade = 1,

        /// DarkTrade
        DarkTrade = 2,

        /// BenchmarkTrade
        BenchmarkTrade = 3,

        /// TechnicalTrade
        TechnicalTrade = 4,

        /// GiveupGiveinTrade
        GiveupGiveinTrade = 5,

        /// ExCumDividendTrade
        ExCumDividendTrade = 6,

        /// TradeWithCondition
        TradeWithCondition = 7,

        /// SummaryReport
        SummaryReport = 15
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `BlockTradeCode_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT BlockTradeCode
{
    typedef Char Base;

    enum Enum
    {
        /// BlockTrade
        BlockTrade = 'B',

        /// RegularTradeOrNegotiatedDeal
        RegularTradeOrNegotiatedDeal = 'N',

        /// Undefined
        Undefined = '-'
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `EffectiveDateIndicator_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT EffectiveDateIndicator
{
    typedef UInt8 Base;

    enum Enum
    {
        /// SellerDeclarationIsReceivedOnTheCurTradingSessionDay
        SellerDeclarationIsReceivedOnTheCurTradingSessionDay = 0,

        /// SellerDeclarationReceivedBeforeTheCurTradingSessionDay
        SellerDeclarationReceivedBeforeTheCurTradingSessionDay = 1
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `IndexPriceCode_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT IndexPriceCode
{
    typedef UInt8 Base;

    enum Enum
    {
        /// OnlyIndex
        OnlyIndex = 0,

        /// IndexAndSessionHigh
        IndexAndSessionHigh = 1,

        /// IndexAndSessionLow
        IndexAndSessionLow = 2,

        /// IndexAndSessionHighAndLowTypicallyFirstPrice
        IndexAndSessionHighAndLowTypicallyFirstPrice = 3,

        /// OnlySessionHigh
        OnlySessionHigh = 4,

        /// OnlySessionLow
        OnlySessionLow = 5,

        /// PreviousDayClose
        PreviousDayClose = 6
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `StatsUpdateType_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT StatsUpdateType
{
    typedef UInt8 Base;

    enum Enum
    {
        /// DailyHigh
        DailyHigh = 5,

        /// DailyLow
        DailyLow = 6,

        /// YearlyHigh
        YearlyHigh = 7,

        /// YearlyLow
        YearlyLow = 8,

        /// LifetimeHigh
        LifetimeHigh = 9,

        /// LifetimeLow
        LifetimeLow = 10,

        /// VariationLastPrice
        VariationLastPrice = 14,

        /// OpenPrice
        OpenPrice = 15,

        /// TradeCount
        TradeCount = 16,

        /// LastTradedPrice
        LastTradedPrice = 17,

        /// PercentVariationPreviousClose
        PercentVariationPreviousClose = 18,

        /// OffBookCumulQty
        OffBookCumulQty = 19,

        /// OnBookAuctionCumulQty
        OnBookAuctionCumulQty = 21,

        /// OnBookContinuousCumulQty
        OnBookContinuousCumulQty = 22,

        /// OnAndOffBookCumulQty
        OnAndOffBookCumulQty = 23
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `GuaranteeIndicator_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT GuaranteeIndicator
{
    typedef UInt8 Base;

    enum Enum
    {
        /// ThisInstrumentIsNotGuaranteed
        ThisInstrumentIsNotGuaranteed = 0,

        /// ThisInstrumentIsGuaranteed
        ThisInstrumentIsGuaranteed = 1,

        /// ThisInstrumentIsNotClearable
        ThisInstrumentIsNotClearable = 2,

        /// GuaranteedClearedBorrowingLendingService
        GuaranteedClearedBorrowingLendingService = 8
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `MMTMarketMechanism_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT MmtMarketMechanism
{
    typedef UInt8 Base;

    enum Enum
    {
        /// CentralLimitOrderBook
        CentralLimitOrderBook = 1,

        /// QuoteDrivenMarket
        QuoteDrivenMarket = 2,

        /// DarkOrderBook
        DarkOrderBook = 3,

        /// OffBookIncludingVoiceOrMessagingTrading
        OffBookIncludingVoiceOrMessagingTrading = 4,

        /// PeriodicAuctionEqualUncrossing
        PeriodicAuctionEqualUncrossing = 5,

        /// RequestForQuotes
        RequestForQuotes = 6,

        /// HybridSystem
        HybridSystem = 8,

        /// AnyOtherExcludingHybrid
        AnyOtherExcludingHybrid = 9
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `EfficientMMTMarketMechanism_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT EfficientMMTMarketMechanism
{
    typedef UInt8 Base;

    enum Enum
    {
        /// CentralLimitOrderBook
        CentralLimitOrderBook = 1,

        /// QuoteDrivenMarket
        QuoteDrivenMarket = 2,

        /// DarkOrderBook
        DarkOrderBook = 3,

        /// OffBookIncludingVoiceOrMessagingTrading
        OffBookIncludingVoiceOrMessagingTrading = 4,

        /// PeriodicAuctionEqualUncrossing
        PeriodicAuctionEqualUncrossing = 5,

        /// RequestForQuotes
        RequestForQuotes = 6,

        /// Other
        Other = 7
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `MMTTradingMode_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT MmtTradingMode
{
    typedef Char Base;

    enum Enum
    {
        /// UndefinedAuctionEqualUncrossing
        UndefinedAuctionEqualUncrossing = '1',

        /// ContinuousTrading
        ContinuousTrading = '2',

        /// AtMarketCloseTrading
        AtMarketCloseTrading = '3',

        /// OutOfMainSessionTrading
        OutOfMainSessionTrading = '4',

        /// TradeReportingOnExchange
        TradeReportingOnExchange = '5',

        /// TradeReportingOffExchange
        TradeReportingOffExchange = '6',

        /// TradeReportingSystematicInternaliser
        TradeReportingSystematicInternaliser = '7',

        /// ScheduledIntradayAuctionEqualUncrossing
        ScheduledIntradayAuctionEqualUncrossing = 'I',

        /// ScheduledClosingAuctionEqualUncrossing
        ScheduledClosingAuctionEqualUncrossing = 'K',

        /// ScheduledOpeningAuctionEqualUncrossing
        ScheduledOpeningAuctionEqualUncrossing = 'O',

        /// UnscheduledAuctionEqualUncrossing
        UnscheduledAuctionEqualUncrossing = 'U',

        /// OnDemandAuctionEqualFrequentBatchedAuction
        OnDemandAuctionEqualFrequentBatchedAuction = 'P'
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `EfficientMMTTradingMode_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT EfficientMMTTradingMode
{
    typedef Char Base;

    enum Enum
    {
        /// UndefinedAuctionEqualUncrossing
        UndefinedAuctionEqualUncrossing = '1',

        /// ContinuousTrading
        ContinuousTrading = '2',

        /// AtMarketCloseTrading
        AtMarketCloseTrading = '3',

        /// OutOfMainSessionTrading
        OutOfMainSessionTrading = '4',

        /// TradeReportingOnExchange
        TradeReportingOnExchange = '5',

        /// TradeReportingOffExchange
        TradeReportingOffExchange = '6',

        /// TradeReportingSystematicInternaliser
        TradeReportingSystematicInternaliser = '7',

        /// ScheduledIntradayAuctionEqualUncrossing
        ScheduledIntradayAuctionEqualUncrossing = 'I',

        /// ScheduledClosingAuctionEqualUncrossing
        ScheduledClosingAuctionEqualUncrossing = 'K',

        /// ScheduledOpeningAuctionEqualUncrossing
        ScheduledOpeningAuctionEqualUncrossing = 'O',

        /// UnscheduledAuctionEqualUncrossing
        UnscheduledAuctionEqualUncrossing = 'U',

        /// OnDemandAuctionEqualFrequentBatchedAuction
        OnDemandAuctionEqualFrequentBatchedAuction = 'P'
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `EfficientMMTTransactionCategory_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT EfficientMMTTransactionCategory
{
    typedef Char Base;

    enum Enum
    {
        /// DarkTrade
        DarkTrade = 'D',

        /// RPRI
        RPRI = 'R',

        /// XFPH
        XFPH = 'Y',

        /// TPAC
        TPAC = 'Z',

        /// NoneApply
        NoneApply = '-'
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `EfficientMMTNegotiationIndicator_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT EfficientMMTNegotiationIndicator
{
    typedef Char Base;

    enum Enum
    {
        /// NLIQ
        NLIQ = '1',

        /// OILQ
        OILQ = '2',

        /// PRIC
        PRIC = '3',

        /// ILQD
        ILQD = '4',

        /// SIZE
        SIZE = '5',

        /// ILQDSIZE
        ILQDSIZE = '6',

        /// NegotiatedTrade
        NegotiatedTrade = 'N',

        /// NoNegotiatedTrade
        NoNegotiatedTrade = '-'
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `EfficientMMTAgencyCrossTradeIndicator_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT EfficientMMTAgencyCrossTradeIndicator
{
    typedef Char Base;

    enum Enum
    {
        /// ACTX
        ACTX = 'X',

        /// NoAgencyCrossTrade
        NoAgencyCrossTrade = '-'
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `EfficientMMTModificationIndicator_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT EfficientMMTModificationIndicator
{
    typedef Char Base;

    enum Enum
    {
        /// AMND
        AMND = 'A',

        /// CANC
        CANC = 'C',

        /// NewTrade
        NewTrade = '-'
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `EfficientMMTBenchmarkIndicator_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT EfficientMMTBenchmarkIndicator
{
    typedef Char Base;

    enum Enum
    {
        /// BENC
        BENC = 'B',

        /// RFPT
        RFPT = 'S',

        /// NoBenchmarkOrReferencePriceTrade
        NoBenchmarkOrReferencePriceTrade = '-'
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `EfficientMMTSpecialDividendIndicator_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT EfficientMMTSpecialDividendIndicator
{
    typedef Char Base;

    enum Enum
    {
        /// SDIV
        SDIV = 'E',

        /// NoSpecialDividendTrade
        NoSpecialDividendTrade = '-'
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `MMTOffBookAutomatedIndicator_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT MmtOffBookAutomatedIndicator
{
    typedef Char Base;

    enum Enum
    {
        /// OffBookNonAutomated
        OffBookNonAutomated = 'M',

        /// OffBookAutomated
        OffBookAutomated = 'Q',

        /// UnspecifiedOrDoesNotApply
        UnspecifiedOrDoesNotApply = '-'
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `EfficientMMTOffBookAutomatedIndicator_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT EfficientMMTOffBookAutomatedIndicator
{
    typedef Char Base;

    enum Enum
    {
        /// OffBookNonAutomated
        OffBookNonAutomated = 'M',

        /// OffBookAutomated
        OffBookAutomated = 'Q',

        /// UnspecifiedOrDoesNotApply
        UnspecifiedOrDoesNotApply = '-'
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `EfficientMMTContributiontoPrice_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT EfficientMMTContributiontoPrice
{
    typedef Char Base;

    enum Enum
    {
        /// TNCP
        TNCP = 'J',

        /// PNDG
        PNDG = 'N',

        /// PlainVanillaTrade
        PlainVanillaTrade = 'P',

        /// NPFT
        NPFT = 'T'
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `EfficientMMTAlgorithmicIndicator_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT EfficientMMTAlgorithmicIndicator
{
    typedef Char Base;

    enum Enum
    {
        /// ALGO
        ALGO = 'H',

        /// NoAlgorithmicTrade
        NoAlgorithmicTrade = '-'
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `EfficientMMTPublicationMode_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT EfficientMMTPublicationMode
{
    typedef Char Base;

    enum Enum
    {
        /// NonImmediatePublication
        NonImmediatePublication = '1',

        /// LRGS
        LRGS = '2',

        /// ILQD
        ILQD = '3',

        /// SIZE
        SIZE = '4',

        /// ILQDSIZE
        ILQDSIZE = '5',

        /// ILQDLRGS
        ILQDLRGS = '6',

        /// ImmediatePublication
        ImmediatePublication = '-'
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `EfficientMMTPostTradeDeferral_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT EfficientMMTPostTradeDeferral
{
    typedef Char Base;

    enum Enum
    {
        /// LMTF
        LMTF = '1',

        /// DATF
        DATF = '2',

        /// VOLO
        VOLO = '3',

        /// FWAF
        FWAF = '4',

        /// IDAF
        IDAF = '5',

        /// VOLW
        VOLW = '6',

        /// FULF
        FULF = '7',

        /// FULA
        FULA = '8',

        /// FULV
        FULV = '9',

        /// FULJ
        FULJ = 'V',

        /// COAF
        COAF = 'W',

        /// NotApplicable
        NotApplicable = '-'
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `EfficientMMTDuplicativeIndicator_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT EfficientMMTDuplicativeIndicator
{
    typedef Char Base;

    enum Enum
    {
        /// DUPL
        DUPL = '1',

        /// UniqueTradeReport
        UniqueTradeReport = '-'
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `TransparencyIndicator_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT TransparencyIndicator
{
    typedef UInt8 Base;

    enum Enum
    {
        /// LitRegularTrade
        LitRegularTrade = 0,

        /// DarkTradeAndImmediatePublication
        DarkTradeAndImmediatePublication = 1,

        /// DarkTradeAndDeferredPublication
        DarkTradeAndDeferredPublication = 2
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `MiFIDInstrumentCategory_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT MiFIDInstrumentCategory
{
    typedef UInt8 Base;

    enum Enum
    {
        /// NotApplicable
        NotApplicable = 0,

        /// RTS1EquityInstrumentFollowingMiFIDDefinition
        RTS1EquityInstrumentFollowingMiFIDDefinition = 1,

        /// RTS2NonEquityInstrumentFollowingMiFIDDefinition
        RTS2NonEquityInstrumentFollowingMiFIDDefinition = 2
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `DynamicCollarLogic_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT DynamicCollarLogic
{
    typedef UInt8 Base;

    enum Enum
    {
        /// NotActive
        NotActive = 0,

        /// NoHaltWithReject
        NoHaltWithReject = 2,

        /// HaltWithAcceptation
        HaltWithAcceptation = 3
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `ReferencePriceOrigin_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT ReferencePriceOrigin
{
    typedef UInt8 Base;

    enum Enum
    {
        /// Internal
        Internal = 1,

        /// External
        External = 2,

        /// ExternalBBO
        ExternalBBO = 3,

        /// OpeningCallPrice
        OpeningCallPrice = 4,

        /// MidBBOOrFairValue
        MidBBOOrFairValue = 5,

        /// FairValue
        FairValue = 6,

        /// FutureMarketPrice
        FutureMarketPrice = 7
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `TaxCode_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT TaxCode
{
    typedef UInt8 Base;

    enum Enum
    {
        /// NotEligibleToPEATheStockHasNeverBeenAMonoryStock
        NotEligibleToPEATheStockHasNeverBeenAMonoryStock = 0,

        /// EligibleToPEA
        EligibleToPEA = 3,

        /// NotProvided
        NotProvided = 9
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `TypeOfMarketAdmission_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT TypeOfMarketAdmission
{
    typedef Char Base;

    enum Enum
    {
        /// InstrumentsTradedOnThePrimaryMarket
        InstrumentsTradedOnThePrimaryMarket = 'A',

        /// InstrumentsTradedOnTheSecondaryMarket
        InstrumentsTradedOnTheSecondaryMarket = 'B',

        /// InstrumentsTradedOnTheNewMarket
        InstrumentsTradedOnTheNewMarket = 'C',

        /// NonRegulatedMarketInstrumentsTradedOnTheFreeMarket
        NonRegulatedMarketInstrumentsTradedOnTheFreeMarket = 'D',

        /// NonRegulatedMarketAlternext
        NonRegulatedMarketAlternext = 'E',

        /// NonListed
        NonListed = 'F',

        /// RegulatedMarketNonEquities
        RegulatedMarketNonEquities = 'G',

        /// RegulatedMarketEquitiesSegmentA
        RegulatedMarketEquitiesSegmentA = 'H',

        /// RegulatedMarketEquitiesSegmentB
        RegulatedMarketEquitiesSegmentB = 'I',

        /// RegulatedMarketEquitiesSegmentC
        RegulatedMarketEquitiesSegmentC = 'J',

        /// RegulatedMarketAllSecuritiesSpecialSegment
        RegulatedMarketAllSecuritiesSpecialSegment = 'K',

        /// RegulatedMarketEquitiesOtherInstruments
        RegulatedMarketEquitiesOtherInstruments = 'L',

        /// OPCVMSICOMINonListedFrenchInvestmentFunds
        OPCVMSICOMINonListedFrenchInvestmentFunds = 'S',

        /// OffMarket
        OffMarket = '6',

        /// GoldCurrenciesAndIndices
        GoldCurrenciesAndIndices = '7',

        /// Foreign
        Foreign = '9'
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `ExerciseStyle_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT ExerciseStyle
{
    typedef UInt8 Base;

    enum Enum
    {
        /// European
        European = 0,

        /// American
        American = 1,

        /// Asian
        Asian = 2,

        /// Bermudan
        Bermudan = 3,

        /// Other
        Other = 4,

        /// Periodic
        Periodic = 5
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `ContractTradingType_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT ContractTradingType
{
    typedef UInt8 Base;

    enum Enum
    {
        /// TradedAsAnOutright
        TradedAsAnOutright = 1,

        /// NotTradedButListedInContractDataTradersMaySubscribeTo
        NotTradedButListedInContractDataTradersMaySubscribeTo = 2,

        /// TradedAsASimpleIntercommoditySpread
        TradedAsASimpleIntercommoditySpread = 3,

        /// TradedAsAnIntercommoditySpread
        TradedAsAnIntercommoditySpread = 4
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `OpenedClosedFund_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT OpenedClosedFund
{
    typedef Char Base;

    enum Enum
    {
        /// Open
        Open = 'O',

        /// Closed
        Closed = 'C'
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `GrossofCDSCIndicator_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT GrossofCDSCIndicator
{
    typedef Char Base;

    enum Enum
    {
        /// No
        No = 'N',

        /// Yes
        Yes = 'Y'
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `PaymentFrequency_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT PaymentFrequency
{
    typedef UInt8 Base;

    enum Enum
    {
        /// Annual
        Annual = 1,

        /// SemiAnnual
        SemiAnnual = 2,

        /// Quarterly
        Quarterly = 3,

        /// Monthly
        Monthly = 4,

        /// BiMonthly
        BiMonthly = 5,

        /// Daily
        Daily = 6,

        /// MigrationNA
        MigrationNA = 7,

        /// Other
        Other = 8,

        /// NoCoupon
        NoCoupon = 9,

        /// AtMaturity
        AtMaturity = 10,

        /// Triannual
        Triannual = 11,

        /// Capitalization
        Capitalization = 12,

        /// IMMDates
        IMMDates = 13,

        /// Bimestrial
        Bimestrial = 14,

        /// Weekly
        Weekly = 15
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `SecurityCondition_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT SecurityCondition
{
    typedef Char Base;

    enum Enum
    {
        /// Normal
        Normal = 'O',

        /// ExDividend
        ExDividend = 'D',

        /// ExCap
        ExCap = 'C',

        /// ExRights
        ExRights = 'R',

        /// ExEntitlement
        ExEntitlement = 'E',

        /// DealingsTemporarilySuspended
        DealingsTemporarilySuspended = 'S',

        /// NotListed
        NotListed = 'N'
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `TaxDescriptionAttachingtoaDividend_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT TaxDescriptionAttachingtoaDividend
{
    typedef Char Base;

    enum Enum
    {
        /// DeducedAtSource
        DeducedAtSource = 'D'
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `TradingPolicy_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT TradingPolicy
{
    typedef UInt8 Base;

    enum Enum
    {
        /// PriceExplicitTime
        PriceExplicitTime = 1,

        /// PriceProRata
        PriceProRata = 2
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `DerivativesMarketModel_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT DerivativesMarketModel
{
    typedef UInt8 Base;

    enum Enum
    {
        /// NoSyntheticQuote
        NoSyntheticQuote = 0,

        /// SpontaneousImpliedMatching
        SpontaneousImpliedMatching = 1,

        /// EventDrivenImpliedMatching
        EventDrivenImpliedMatching = 2
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `DerivativesInstrumentType_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT DerivativesInstrumentType
{
    typedef UInt8 Base;

    enum Enum
    {
        /// CallOption
        CallOption = 0,

        /// PutOption
        PutOption = 1,

        /// Strategy
        Strategy = 2,

        /// IndividualFuture
        IndividualFuture = 3,

        /// Underlying
        Underlying = 4
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `Anonymous_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT Anonymous
{
    typedef UInt8 Base;

    enum Enum
    {
        /// No
        No = 0,

        /// Yes
        Yes = 1
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `PriceQualifier_enum` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT PriceQualifier
{
    typedef UInt8 Base;

    enum Enum
    {
        /// LastAdjustedClosingPrice
        LastAdjustedClosingPrice = 1,

        /// LastTradedPrice
        LastTradedPrice = 2,

        /// VolumeWeightedAveragePrice
        VolumeWeightedAveragePrice = 3,

        /// ClosingUncrossingPrice
        ClosingUncrossingPrice = 4,

        /// ValuationPrice
        ValuationPrice = 5,

        /// AverageOfBBO
        AverageOfBBO = 6,

        /// AverageOfBestBid
        AverageOfBestBid = 7,

        /// UpdatedByMarketOperations
        UpdatedByMarketOperations = 8,

        /// ClosingPriceOfReferenceMarket
        ClosingPriceOfReferenceMarket = 9
    };

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    static
    std::string
    toString(
        Enum);
};

/// `MMProtections_set` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT MmProtections
{
public:
    /// Aliases integral type whose bits
    /// are used to indicate flag presence.
    typedef UInt8 Bits;

    enum
    {
        Size = sizeof(Bits)
    };


    /// \private
    /// Init traits.
    struct MemberTraits
    {
        enum { Count = 1 };

        typedef Bits FirstArgType;
    };

    /// Indicates whether Delta bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool delta() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x1);
    }

    /// Indicates whether Volume bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool volume() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x2);
    }

    /// \return elements as they packed in the set.
    Bits bits() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return bits_;
    }

    /// Constructs from a value.
    explicit
    MmProtections(Bits bits = 0)
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
      : bits_(bits)
    {
    }

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    std::string
    toString() const;

    /// Compares encoded data
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool
    operator!=(
        const MmProtections& other) const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return !(*this == other);
    }

    /// Compares encoded data
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool
    operator==(
        const MmProtections& other) const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return this->bits_ == other.bits_;
    }

private:
    Bits bits_;
};

/// `TradeQualifier_set` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT TradeQualifier
{
public:
    /// Aliases integral type whose bits
    /// are used to indicate flag presence.
    typedef UInt8 Bits;

    enum
    {
        Size = sizeof(Bits)
    };


    /// \private
    /// Init traits.
    struct MemberTraits
    {
        enum { Count = 1 };

        typedef Bits FirstArgType;
    };

    /// Indicates whether UncrossingTrade bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool uncrossingTrade() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x1);
    }

    /// Indicates whether FirstTradePrice bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool firstTradePrice() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x2);
    }

    /// Indicates whether PassiveOrder bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool passiveOrder() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x4);
    }

    /// Indicates whether AggressiveOrder bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool aggressiveOrder() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x8);
    }

    /// Indicates whether TradeCreationByMarketOperations bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool tradeCreationByMarketOperations() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x10);
    }

    /// Indicates whether NAVTradeExpressedInBps bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool navTradeExpressedInBps() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x20);
    }

    /// Indicates whether NAVTradeExpressedInPriceCurrency bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool navTradeExpressedInPriceCurrency() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x40);
    }

    /// Indicates whether DeferredPublication bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool deferredPublication() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x80);
    }

    /// \return elements as they packed in the set.
    Bits bits() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return bits_;
    }

    /// Constructs from a value.
    explicit
    TradeQualifier(Bits bits = 0)
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
      : bits_(bits)
    {
    }

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    std::string
    toString() const;

    /// Compares encoded data
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool
    operator!=(
        const TradeQualifier& other) const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return !(*this == other);
    }

    /// Compares encoded data
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool
    operator==(
        const TradeQualifier& other) const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return this->bits_ == other.bits_;
    }

private:
    Bits bits_;
};

/// `PhaseQualifier_set` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT PhaseQualifier
{
public:
    /// Aliases integral type whose bits
    /// are used to indicate flag presence.
    typedef UInt16 Bits;

    enum
    {
        Size = sizeof(Bits)
    };


    /// \private
    /// Init traits.
    struct MemberTraits
    {
        enum { Count = 1 };

        typedef Bits FirstArgType;
    };

    /// Indicates whether NoQualifier bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool qualifier() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x1);
    }

    /// Indicates whether CallBBOOnly bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool callBBOOnly() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x2);
    }

    /// Indicates whether TradingAtLast bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool tradingAtLast() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x4);
    }

    /// Indicates whether RandomUncrossing bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool randomUncrossing() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x8);
    }

    /// Indicates whether Suspended bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool suspended() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x10);
    }

    /// Indicates whether WholesaleAllowed bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool wholesaleAllowed() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x20);
    }

    /// Indicates whether StressedMarketConditions bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool stressedMarketConditions() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x40);
    }

    /// Indicates whether ExceptionalMarketConditions bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool exceptionalMarketConditions() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x80);
    }

    /// Indicates whether QuotingPeriod bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool quotingPeriod() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x200);
    }

    /// Indicates whether ExecutionPreventionAcrossAllFirms bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool executionPreventionAcrossAllFirms() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x400);
    }

    /// \return elements as they packed in the set.
    Bits bits() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return bits_;
    }

    /// Constructs from a value.
    explicit
    PhaseQualifier(Bits bits = 0)
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
      : bits_(bits)
    {
    }

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    std::string
    toString() const;

    /// Compares encoded data
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool
    operator!=(
        const PhaseQualifier& other) const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return !(*this == other);
    }

    /// Compares encoded data
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool
    operator==(
        const PhaseQualifier& other) const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return this->bits_ == other.bits_;
    }

private:
    Bits bits_;
};

/// `StrategyAuthorized_set` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT StrategyAuthorized
{
public:
    /// Aliases integral type whose bits
    /// are used to indicate flag presence.
    typedef UInt64 Bits;

    enum
    {
        Size = sizeof(Bits)
    };


    /// \private
    /// Init traits.
    struct MemberTraits
    {
        enum { Count = 1 };

        typedef Bits FirstArgType;
    };

    /// Indicates whether JellyRoll bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool jellyRoll() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x1);
    }

    /// Indicates whether Butterfly bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool butterfly() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x2);
    }

    /// Indicates whether CallOrPutCabinet bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool callOrPutCabinet() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x4);
    }

    /// Indicates whether Spread bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool spread() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x8);
    }

    /// Indicates whether CalendarSpread bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool calendarSpread() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x10);
    }

    /// Indicates whether DiagonalCalendarSpread bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool diagonalCalendarSpread() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x20);
    }

    /// Indicates whether Guts bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool guts() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x40);
    }

    /// Indicates whether TwoByOneRatioSpread bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool twoByOneRatioSpread() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x80);
    }

    /// Indicates whether IronButterfly bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool ironButterfly() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x100);
    }

    /// Indicates whether Combo bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool combo() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x200);
    }

    /// Indicates whether Strangle bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool strangle() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x400);
    }

    /// Indicates whether Ladder bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool ladder() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x800);
    }

    /// Indicates whether Strip bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool strip() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x1000);
    }

    /// Indicates whether StraddleCalendarSpread bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool straddleCalendarSpread() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x2000);
    }

    /// Indicates whether Pack bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool pack() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x4000);
    }

    /// Indicates whether DiagonalStraddleCalendarSpread bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool diagonalStraddleCalendarSpread() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x8000);
    }

    /// Indicates whether SimpleInterCommoditySpread bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool simpleInterCommoditySpread() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x10000);
    }

    /// Indicates whether ConversionReversal bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool conversionReversal() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x20000);
    }

    /// Indicates whether Straddle bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool straddle() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x40000);
    }

    /// Indicates whether VolatilityTrade bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool volatilityTrade() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x80000);
    }

    /// Indicates whether Condor bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool condor() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x100000);
    }

    /// Indicates whether Box bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool box() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x200000);
    }

    /// Indicates whether Bundle bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool bundle() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x400000);
    }

    /// Indicates whether ReducedTickSpread bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool reducedTickSpread() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x800000);
    }

    /// Indicates whether LadderVersusUnderlying bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool ladderVersusUnderlying() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x1000000);
    }

    /// Indicates whether ButterflyVersusUnderlying bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool butterflyVersusUnderlying() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x2000000);
    }

    /// Indicates whether CallSpreadVersusPutVersusUnderlying bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool callSpreadVersusPutVersusUnderlying() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x4000000);
    }

    /// Indicates whether CallOrPutSpreadVersusUnderlying bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool callOrPutSpreadVersusUnderlying() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x8000000);
    }

    /// Indicates whether CallOrPutCalendarSpreadVersusUnderlying bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool callOrPutCalendarSpreadVersusUnderlying() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x10000000);
    }

    /// Indicates whether CallPutDiagonalCalendarSpreadVersusUnderlying bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool callPutDiagonalCalendarSpreadVersusUnderlying() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x20000000);
    }

    /// Indicates whether GutsVersusUnderlying bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool gutsVersusUnderlying() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x40000000);
    }

    /// Indicates whether TwoByOneCallOrPutRatioSpreadVersusUnderlying bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool twoByOneCallOrPutRatioSpreadVersusUnderlying() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x80000000);
    }

    /// Indicates whether IronButterflyVersusUnderlying bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool ironButterflyVersusUnderlying() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x100000000);
    }

    /// Indicates whether ComboVersusUnderlying bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool comboVersusUnderlying() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x200000000);
    }

    /// Indicates whether StrangleVersusUnderlying bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool strangleVersusUnderlying() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x400000000);
    }

    /// Indicates whether ExchangeForPhysical bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool exchangeForPhysical() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x800000000);
    }

    /// Indicates whether StraddleCalendarSpreadVersusUnderlying bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool straddleCalendarSpreadVersusUnderlying() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x1000000000);
    }

    /// Indicates whether PutSpreadVersusCallVersusUnderlying bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool putSpreadVersusCallVersusUnderlying() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x2000000000);
    }

    /// Indicates whether DiagonalStraddleCalendarSpreadVersusUnderlying bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool diagonalStraddleCalendarSpreadVersusUnderlying() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x4000000000);
    }

    /// Indicates whether Synthetic bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool synthetic() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x8000000000);
    }

    /// Indicates whether StraddleVersusUnderlying bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool straddleVersusUnderlying() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x10000000000);
    }

    /// Indicates whether CondorVersusUnderlying bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool condorVersusUnderlying() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x20000000000);
    }

    /// Indicates whether BuyWrite bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool buyWrite() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x40000000000);
    }

    /// Indicates whether IronCondorVersusUnderlying bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool ironCondorVersusUnderlying() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x80000000000);
    }

    /// Indicates whether IronCondor bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool ironCondor() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x100000000000);
    }

    /// Indicates whether CallSpreadVersusSellAPut bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool callSpreadVersusSellAPut() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x200000000000);
    }

    /// Indicates whether PutSpreadVersusSellACall bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool putSpreadVersusSellACall() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x400000000000);
    }

    /// Indicates whether PutStraddleVersusSellACallOrAPut bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool putStraddleVersusSellACallOrAPut() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x800000000000);
    }

    /// \return elements as they packed in the set.
    Bits bits() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return bits_;
    }

    /// Constructs from a value.
    explicit
    StrategyAuthorized(Bits bits = 0)
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
      : bits_(bits)
    {
    }

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    std::string
    toString() const;

    /// Compares encoded data
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool
    operator!=(
        const StrategyAuthorized& other) const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return !(*this == other);
    }

    /// Compares encoded data
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool
    operator==(
        const StrategyAuthorized& other) const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return this->bits_ == other.bits_;
    }

private:
    Bits bits_;
};

/// `OrderTypeRules_set` type.
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT OrderTypeRules
{
public:
    /// Aliases integral type whose bits
    /// are used to indicate flag presence.
    typedef UInt16 Bits;

    enum
    {
        Size = sizeof(Bits)
    };


    /// \private
    /// Init traits.
    struct MemberTraits
    {
        enum { Count = 1 };

        typedef Bits FirstArgType;
    };

    /// Indicates whether Market bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool market() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x1);
    }

    /// Indicates whether Limit bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool limit() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x2);
    }

    /// Indicates whether StopStopLoss bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool stopStopLoss() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x4);
    }

    /// Indicates whether StopLimit bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool stopLimit() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x8);
    }

    /// Indicates whether MarketOnOpenMOO bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool marketOnOpenMOO() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x10);
    }

    /// Indicates whether TradeAtSettlement bit is set.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool tradeAtSettlement() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x20);
    }

    /// \return elements as they packed in the set.
    Bits bits() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return bits_;
    }

    /// Constructs from a value.
    explicit
    OrderTypeRules(Bits bits = 0)
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
      : bits_(bits)
    {
    }

    /// \return a human-readable presentation.
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    std::string
    toString() const;

    /// Compares encoded data
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool
    operator!=(
        const OrderTypeRules& other) const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return !(*this == other);
    }

    /// Compares encoded data
    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool
    operator==(
        const OrderTypeRules& other) const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return this->bits_ == other.bits_;
    }

private:
    Bits bits_;
};


/// Null value for an optional UnsignedChar field.
typedef
IntegralConstant<UInt8, 255>
NullUnsignedChar;


/// Null value for an optional Int8 field.
typedef
IntegralConstant<Int8, -128>
NullInt8;


/// Null value for an optional Uint16 field.
typedef
IntegralConstant<UInt16, 65535>
NullUint16;


/// Null value for an optional Uint32 field.
typedef
IntegralConstant<UInt32, 4294967295>
NullUint32;


/// Null value for an optional Uint64 field.
typedef
IntegralConstant<UInt64, 18446744073709551615ULL>
NullUint64;


/// Null value for an optional Int32 field.
typedef
IntegralConstant<Int32, -2147483647-1>
NullInt32;


/// Null value for an optional Int64 field.
typedef
IntegralConstant<Int64, -9223372036854775807LL-1>
NullInt64;


/// Null value for an optional Time field.
typedef
IntegralConstant<UInt64, 0ULL>
NullTime;



typedef
IntegralConstant<UInt8, 255>
NullUInt8;

typedef
IntegralConstant<Char, -128>
NullChar;

typedef
IntegralConstant<UInt64 , 18446744073709551615ULL>
NullUInt64;

ONIXS_EURONEXT_OPTIQMDG_MESSAGING_NAMESPACE_END