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

typedef UInt8 UnsignedChar;
 

typedef Int8 Int8;
 

typedef UInt16 Uint16;
 

typedef UInt32 Uint32;
 

typedef UInt64 Uint64;
 

typedef Int32 Int32;
 

typedef Int64 Int64;
 

typedef UInt64 Time;
 

typedef Char Char1;
 

typedef Char Char2[2];
 

typedef Char Char3[3];
 

typedef Char Char4[4];
 

typedef Char Char5[5];
 

typedef Char Char6[6];
 

typedef Char Char7[7];
 

typedef Char Char8[8];
 

typedef Char Char10[10];
 

typedef Char Char11[11];
 

typedef Char Char12[12];
 

typedef Char Char13[13];
 

typedef Char Char15[15];
 

typedef Char Char16[16];
 

typedef Char Char18[18];
 

typedef Char Char20[20];
 

typedef Char Char24[24];
 

typedef Char Char25[25];
 

typedef Char Char27[27];
 

typedef Char Char30[30];
 

typedef Char Char32[32];
 

typedef Char Char50[50];
 

typedef Char Char52[52];
 

typedef Char Char60[60];
 

typedef Char Char100[100];
 

typedef Char Char102[102];
 

typedef Char Char250[250];
 

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT PricingAlgorithm
{
    typedef UInt8 Base;
 
    enum Enum
    {
        Standard = 0,

        TotalReturnFuture = 1,

        MarketOnClose = 2,

        StandardWithNegativePrices = 3
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT AccountType
{
    typedef UInt8 Base;
 
    enum Enum
    {
        Client = 1,

        House = 2,

        RO = 4,

        AssignedBroker = 5,

        LiquidityProvider = 6,

        RelatedParty = 7,

        StructuredProductMarketMaker = 8,

        OmegaClient = 14,

        CeresClient = 15
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT Session
{
    typedef UInt8 Base;
 
    enum Enum
    {
        Session0 = 0,

        Session1 = 1,

        Session2 = 2,

        Session3 = 3,

        Session4 = 4,

        Session5 = 5,

        Session6 = 6,

        Session7 = 7,

        Session8 = 8,

        Session9 = 9
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT TechnicalNotificationType
{
    typedef UInt8 Base;
 
    enum Enum
    {
        InstrumentBookRetransmissionEnd = 1,

        TradeRetransmissionStart = 10,

        TradeRetransmissionEnd = 11
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT ScheduledEvent
{
    typedef UInt8 Base;
 
    enum Enum
    {
        CancelPreviouslyScheduledEvent = 0,

        Reopening = 1,

        ResumptionOfTrading = 3,

        Closed = 4,

        Expiry = 5,

        WholesaleLargeInScaleLiSTradesOpenExtension = 6,

        WholesaleBasisTradesOpenExtension = 7,

        WholesaleAgainstActualsTradesOpenExtension = 8,

        WholesaleLargeInScaleLiSPackageTradesOpenExtension = 9,

        WholesaleExchangeForSwapsTradesOpenExtension = 10,

        WholesaleTradesOpenExtension = 11,

        Suspension = 12,

        CollarsNormal = 13,

        CollarsWide = 14,

        PreExpiry = 15,

        ClosingPrice = 16
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT StatusReason
{
    typedef UInt8 Base;
 
    enum Enum
    {
        Scheduled = 0,

        CollarsBreach = 4,

        AutomaticReopening = 7,

        NoLiquidityProvider = 8,

        KnockInByIssuer = 11,

        KnockOutByExchange = 12,

        KnockOutByIssuer = 13,

        ActionByMarketOperations = 15,

        WaitingForTradableState = 16,

        NewListing = 20,

        DueToUnderlying = 21,

        OutsideOfLPQuotes = 22,

        Technical = 23,

        DueToLeg = 24,

        DueToMainMarket = 25
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT ImbalanceQuantitySide
{
    typedef UInt8 Base;
 
    enum Enum
    {
        NoImbalance = 0,

        Buy = 1,

        Sell = 2
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT InstrumentCategory
{
    typedef UInt8 Base;
 
    enum Enum
    {
        Equities = 1,

        FixedIncome = 2,

        WarrantsAndCertificates = 3,

        Trackers = 6,

        Futures = 7,

        Options = 10,

        Indices = 11,

        EuronextFundsServices = 12,

        INAVIndicativeNetAssetValue = 14,

        Fund = 15,

        Forex = 16,

        Miscellaneous = 254
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT InstrumentUnitExpression
{
    typedef UInt8 Base;
 
    enum Enum
    {
        Units = 1,

        PercentageOfNominalExcludingAccruedInterestClean = 2,

        BasisPoints = 3,

        PercentageMixed = 4,

        PercentageOfNominalIncludingAccruedInterestDirty = 5,

        PercentageOfParValue = 6,

        Yield = 7,

        Kilograms = 8,

        Ounces = 9
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT RepoIndicator
{
    typedef UInt8 Base;
 
    enum Enum
    {
        InstrNeitherEligibleForSRDOrLoanAndLendingMkt = 0,

        InstrEligibleForSRDAndForLoanAndLendingMarket = 1,

        InstrEligibleForTheSRDLongOnly = 2,

        InstrEligibleForLoanAndLendingMktAndForSRDLongOnly = 3,

        EasytoborrowInstrEligibleForSRDAndForLoanAndLendingMkt = 4,

        InstrEligibleForTheLoanAndLendingMarket = 5,

        NonSignificant = 8
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT StrikeCurrencyIndicator
{
    typedef UInt8 Base;
 
    enum Enum
    {
        ChangeRateNotAppliedToTheStrikePrice = 0,

        ChangeRateAppliedToTheStrikePrice = 1
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT TradingCurrencyIndicator
{
    typedef UInt8 Base;
 
    enum Enum
    {
        ChangeRateNotAppliedToTheTradedPrice = 0,

        ChangeRateAppliedToTheTradedPrice = 1
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT ContractType
{
    typedef Char Base;
 
    enum Enum
    {
        Future = 'F',

        Option = 'O',

        Underlying = 'U'
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT ExpiryCycleType
{
    typedef UInt8 Base;
 
    enum Enum
    {
        Daily = 1,

        Weekly = 2,

        Monthly = 3,

        Quarterly = 4,

        HalfYearly = 5,

        Yearly = 6
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT MessagePriceNotation
{
    typedef UInt8 Base;
 
    enum Enum
    {
        Price = 1,

        SpreadInBasisPoints = 2,

        Spread = 3
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT UnderlyingType
{
    typedef Char Base;
 
    enum Enum
    {
        BasketWithCommodity = 'A',

        Basket = 'B',

        Commodity = 'C',

        DepositaryReceipt = 'D',

        Future = 'F',

        CurrencyLeveragedIndex = 'G',

        Other = 'H',

        Index = 'I',

        Bonds = 'J',

        StockDividend = 'K',

        LeveragedIndex = 'L',

        InterestRate = 'N',

        OtherDerivative = 'O',

        CommodityIndex = 'P',

        CommodityLeveragedIndex = 'Q',

        Right = 'R',

        Stock = 'S',

        Credit = 'T',

        Fund = 'U',

        Currency = 'V',

        StockWarrant = 'W',

        ExchangeRate = 'X',

        SecurityLeveragedIndex = 'Z'
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT StrategyCode
{
    typedef Char Base;
 
    enum Enum
    {
        JellyRoll = 'A',

        Butterfly = 'B',

        CallOrPutCabinet = 'C',

        Spread = 'D',

        CalendarSpread = 'E',

        DiagonalCalendarSpread = 'F',

        Guts = 'G',

        TwoByOneRatioSpread = 'H',

        IronButterfly = 'I',

        Combo = 'J',

        Strangle = 'K',

        Ladder = 'L',

        Strip = 'M',

        StraddleCalendarSpread = 'N',

        Pack = 'O',

        DiagonalStraddleCalendarSpread = 'P',

        SimpleInterCommoditySpread = 'Q',

        ConversionReversal = 'R',

        Straddle = 'S',

        VolatilityTrade = 'V',

        Condor = 'W',

        Box = 'X',

        Bundle = 'Y',

        ReducedTickSpread = 'Z',

        LadderVersusUnderlying = 'a',

        ButterflyVersusUnderlying = 'b',

        CallSpreadVersusPutVersusUnderlying = 'c',

        CallOrPutSpreadVersusUnderlying = 'd',

        CallOrPutCalendarSpreadVersusUnderlying = 'e',

        CallPutDiagonalCalendarSpreadVersusUnderlying = 'f',

        GutsVersusUnderlying = 'g',

        TwoByOneCallOrPutRatioSpreadVersusUnderlying = 'h',

        IronButterflyVersusUnderlying = 'i',

        ComboVersusUnderlying = 'j',

        StrangleVersusUnderlying = 'k',

        ExchangeForPhysical = 'm',

        StraddleCalendarSpreadVersusUnderlying = 'n',

        PutSpreadVersusCallVersusUnderlying = 'p',

        DiagonalStraddleCalendarSpreadVersusUnderlying = 'q',

        Synthetic = 'r',

        StraddleVersusUnderlying = 's',

        CondorVersusUnderlying = 't',

        BuyWrite = 'u',

        IronCondorVersusUnderlying = 'v',

        IronCondor = 'w',

        CallSpreadVersusSellAPut = 'x',

        PutSpreadVersusSellACall = 'y',

        PutStraddleVersusSellACallOrAPut = 'z',

        ICSOneSidedCombinationSameExpiry = 'T',

        ICSTwoSidedCombinationSameExpiry = 'U'
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT MarketDataActionType
{
    typedef UInt8 Base;
 
    enum Enum
    {
        NewOrder = 1,

        DeletionOfIdentifiedOrder = 2,

        DeletionOfAllOrdersBySide = 3,

        ModificationOfExistingOrderWithoutLossOfPriority = 4,

        RetransmissionOfAllOrders = 5,

        ModificationOfExistingOrderWithLossOfPriority = 6,

        RFQAnswerCreation = 7,

        RFQAnswerDeletion = 8
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT MarketDataPriceType
{
    typedef UInt8 Base;
 
    enum Enum
    {
        OfficialDaily = 2,

        OfficialMarketClose = 4,

        OfficialExpiry = 6,

        ProvisionalIntraday = 7,

        OfficialIntraday = 8,

        OfficialYDSP = 9,

        NAVForTheInstrumentsEligibleToTheNAVTradingFacility = 10,

        AdjustedClosingPrice = 12,

        SubscriptionPrice = 13,

        IndicativeMatchingPrice = 14,

        MinPriceOutOfSessionTrades = 19,

        MaxPriceOutOfSessionTrades = 20,

        MinPriceOutOfSessionBlockTrades = 21,

        MaxPriceOutOfSessionBlockTrades = 22,

        ValuationPrice = 23,

        FundSubscription = 24,

        FundRedemption = 25,

        UncrossingPrice = 26,

        LastTradedPrice = 27,

        AIP = 28,

        NetAssetValue = 30,

        ExternalReferencePrice = 31,

        ClosingPrice = 33
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT UnderlyingSubtype
{
    typedef UInt8 Base;
 
    enum Enum
    {
        Basket = 0,

        Dividend = 1,

        ETF = 2,

        Share = 3,

        DividendIndex = 4,

        EquityIndex = 5,

        TRFIndex = 6,

        VolatilityIndex = 7,

        FutureOnCommodities = 8,

        FXCrossRates = 9,

        FXEmergingMarkets = 10,

        FXMajors = 11,

        Agricultural = 12,

        Environmental = 13,

        Freight = 14,

        Fertilizer = 15,

        IndustrialProducts = 16,

        Inflation = 17,

        MultiCommodityExotic = 18,

        Metals = 19,

        Energy = 20,

        OfficialEconomicStatistics = 21,

        OtherC10 = 22,

        Other = 23,

        Paper = 24,

        Polypropylene = 25,

        BondsBasket = 26
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT QuoteUpdateType
{
    typedef UInt8 Base;
 
    enum Enum
    {
        BestBid = 1,

        BestOffer = 2,

        CancelBid = 5,

        CancelOffer = 6
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT MarketDataUpdateType
{
    typedef UInt8 Base;
 
    enum Enum
    {
        BestBid = 1,

        BestOffer = 2,

        NewBid = 3,

        NewOffer = 4,

        UpdatedBid = 5,

        UpdatedOffer = 6,

        TotalTradedVolume = 7,

        ImpliedBid = 8,

        ImpliedOffer = 9,

        RequestForQuote = 10,

        RequestForQuoteBid = 11,

        RequestForSize = 12,

        RequestForQuoteOffer = 13,

        HighDynamicCollar = 14,

        LowDynamicCollar = 15,

        NewBidRLP = 16,

        NewOfferRLP = 17,

        UpdatedBidRLP = 18,

        UpdatedOfferRLP = 19,

        ConventionalTrade = 24,

        RequestForCrossRFCQueued = 25,

        RequestForCrossRFC = 26,

        LargeInScaleLiSTrade = 27,

        BasisTrade = 28,

        LargeInScaleLiSPackageTrade = 29,

        GuaranteedCrossTrade = 30,

        AgainstActualTrade = 31,

        AssetAllocationTrade = 32,

        ExchangeForSwapTrade = 34,

        DarkTrade = 35,

        ExchangeForPhysicalTradeCashLeg = 36,

        StrategyLegConventionalTrade = 37,

        StrategyLegLargeInScaleLiSTrade = 38,

        StrategyLegBasisTrade = 39,

        StrategyLegGuaranteedCrossTrade = 40,

        StrategyLegAgainstActualTrade = 41,

        StrategyLegAssetAllocationTrade = 42,

        StrategyLegExchangeForSwapTrade = 44,

        StrategyLegExchangeForPhysicalTrade = 45,

        BoBTrade = 46,

        AtomXTrade = 48,

        TradeCancellation = 50,

        OutOfMarketTrade = 51,

        DeltaNeutralTradeUnderlyingCashLeg = 52,

        DeltaNeutralTradeUnderlyingFutureLeg = 53,

        EuronextFundServiceTrade = 54,

        SecondaryListingTrade = 55,

        RequestForCrossTrade = 56,

        RequestForCrossStrategyLegTrade = 57,

        NewBidWithLiquidityProvider = 58,

        NewOfferWithLiquidityProvider = 59,

        UpdatedBidWithLiquidityProvider = 60,

        UpdatedOfferWithLiquidityProvider = 61,

        LowStaticCollar = 63,

        HighStaticCollar = 64,

        MarketVWAPOperationTrade = 65,

        RequestForSizeBid = 66,

        RequestForSizeOffer = 67,

        LowLPCollar = 70,

        HighLPCollar = 71,

        ETFMTFNAVTradePriceInBp = 72,

        ETFMTFNAVDarkTradePriceInBp = 73,

        NewBidOnWholesaleRFC = 74,

        NewOfferOnWholesaleRFC = 75,

        UpdatedBidOnWholesaleRFC = 76,

        UpdatedOfferOnWholesaleRFC = 77,

        ClearWholesaleRFC = 78,

        GuaranteedCrossNegotiatedDealNLIQ = 79,

        GuaranteedCrossNegotiatedDealOILQ = 80,

        LargeInScaleTrade = 81,

        LargeInScaleTradeInBasisPoints = 82,

        LargeInScalePackageTradeInBasisPoints = 83,

        StrategyLegLargeInScaleTradeInBasisPoints = 84,

        NewBidRFQAnswer = 86,

        NewOfferRFQAnswer = 87,

        UpdatedBidRFQAnswer = 88,

        UpdatedOfferRFQAnswer = 89,

        BidExecutionSummary = 90,

        AQSExpansionFactor = 91,

        CollarsExpansionFactor = 92,

        CollarsEnabled = 93,

        CollarsDisabled = 94,

        DCRPInterMonthSpread = 95,

        FSPReferencePrice = 96,

        OfferExecutionSummary = 97,

        FSPTriggered = 98,

        MidPointBBO = 99,

        ConventionalTradeProvisionalPrice = 100,

        HighOrderPriceControlCollar = 101,

        LowOrderPriceControlCollar = 102,

        OrderPriceControlCollarReferencePrice = 103,

        IssuingOrTenderOfferTrade = 104,

        RFQTrade = 105,

        FLIPSpread = 106,

        FLIPReferencePrice = 107,

        ClearBook = 254
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT MarketDataChangeType
{
    typedef UInt8 Base;
 
    enum Enum
    {
        StatusChanges = 0,

        ScheduledEventNotification = 1,

        StatusChangeAndScheduledEventNotification = 2
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT Emm
{
    typedef UInt8 Base;
 
    enum Enum
    {
        CashAndDerivativeCentralOrderBook = 1,

        NAVTradingFacility = 2,

        DerivativesWholesales = 4,

        CashOnExchangeOffBook = 5,

        EuronextOffExchangeTradeReports = 6,

        DerivativesOnExchangeOffBook = 7,

        ETFMTFNAVCentralOrderBook = 8,

        ListedNotTraded = 9,

        DeltaNeutralContingencyLeg = 15,

        NotApplicable = 99
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT MarketModel
{
    typedef UInt8 Base;
 
    enum Enum
    {
        OrderDriven = 1,

        QuoteDriven = 2,

        IPO = 3,

        PrimaryMarket = 4,

        RFQ = 5,

        ConditionalUncrossing = 6
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT OrderEntryQualifier
{
    typedef UInt8 Base;
 
    enum Enum
    {
        OrderEntryCancelModifyDisabled = 0,

        OrderEntryCancelModifyEnabled = 1,

        CancelAndModifyOnly = 2,

        CancelOnly = 3
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT OrderSide
{
    typedef UInt8 Base;
 
    enum Enum
    {
        Buy = 1,

        Sell = 2,

        Cross = 3
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT OrderType
{
    typedef UInt8 Base;
 
    enum Enum
    {
        Market = 1,

        Limit = 2,

        StopMarketOrStopMarketOnQuote = 3,

        StopLimitOrStopLimitOnQuote = 4,

        PrimaryPeg = 5,

        MarketToLimit = 6,

        MarketPeg = 7,

        MidPointPeg = 8,

        AveragePrice = 9,

        Iceberg = 10
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT BookState
{
    typedef UInt8 Base;
 
    enum Enum
    {
        Inaccessible = 1,

        Closed = 2,

        Call = 3,

        Uncrossing = 4,

        Continuous = 5,

        Halted = 6,

        ContinuousUncrossing = 7,

        Suspended = 8,

        Reserved = 9
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT PhaseId
{
    typedef UInt8 Base;
 
    enum Enum
    {
        Inaccessible = 1,

        Closed = 2,

        Call = 3,

        Uncrossing = 4,

        Continuous = 5,

        ContinuousUncrossing = 7
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT InstrumentState
{
    typedef UInt8 Base;
 
    enum Enum
    {
        Scheduled = 1,

        SuspendedDueToUnderlying = 2,

        SuspendedKOBI = 3,

        SuspendedKOBE = 4,

        SuspendedNewListing = 5,

        SuspendedByMO = 6,

        SuspendedTechnical = 7,

        ReservedDynamicCollars = 8,

        ReservedStaticCollars = 9,

        ReservedWaitingForLP = 10,

        ReservedLPLimit = 11,

        InstrumentDeletion = 12,

        SuspendedWaitingForBBO = 13,

        SuspendedWaitingForTradableState = 14,

        RandomUncrossingPeriod = 15,

        Expired = 16,

        Uncrossing = 17,

        ReservedDueToLeg = 18,

        SuspendedDueToLeg = 19,

        ReservedFutureLimitInterruptionProtection = 21,

        SuspendedWaitingForMarketOperations = 22
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT TradeType
{
    typedef UInt8 Base;
 
    enum Enum
    {
        ConventionalTrade = 1,

        LargeInScaleLiSTrade = 2,

        BasisTrade = 3,

        LargeInScaleLiSPackageTrade = 4,

        GuaranteedCrossTrade = 5,

        AgainstActualTrade = 6,

        AssetAllocationTrade = 7,

        ExchangeForSwapTrade = 9,

        ExchangeForPhysicalTradeCashLeg = 10,

        StrategyLegConventionalTrade = 11,

        StrategyLegLargeInScaleLiSTrade = 12,

        StrategyLegBasisTrade = 13,

        StrategyLegGuaranteedCrossTrade = 14,

        StrategyLegAgainstActualTrade = 15,

        StrategyLegAssetAllocationTrade = 16,

        StrategyLegExchangeForSwapTrade = 18,

        StrategyLegExchangeForPhysicalTrade = 19,

        BoBTrade = 20,

        AtomXTrade = 22,

        TradeCancellation = 24,

        OutOfMarketTrade = 25,

        DeltaNeutralTradeUnderlyingCashLeg = 26,

        MarketVWAPOperationTrade = 27,

        EuronextFundServiceTrade = 28,

        SecondaryListingTrade = 29,

        RequestForCrossTrade = 30,

        RequestForCrossStrategyLegTrade = 31,

        TradePublication = 32,

        DarkTrade = 33,

        DeltaNeutralTradeUnderlyingFutureLeg = 34,

        TotalTradedVolume = 36,

        ETFMTFNAVTradePriceInBp = 37,

        ETFMTFNAVDarkTradePriceInBp = 38,

        GuaranteedCrossNegotiatedDealNLIQ = 39,

        GuaranteedCrossNegotiatedDealOILQ = 40,

        LargeInScaleTrade = 41,

        LargeInScaleTradeInBasisPoints = 42,

        LargeInScalePackageTradeInBasisPoints = 43,

        StrategyLegLargeInScaleTradeInBasisPoints = 44,

        TradeReversal = 45,

        NonStandardSettlement = 46,

        RepurchaseAgreementRepo = 47,

        ExchangeGrantedTrade = 48,

        Other = 49,

        OddLot = 50,

        ConventionalTradeProvisionalPrice = 100,

        LargeInScaleLiSTradeProvisionalPrice = 101,

        LargeInScaleLiSPackageTradeProvisionalPrice = 102,

        IssuingOrTenderOfferTrade = 103,

        RFQTrade = 104
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT TradingPeriod
{
    typedef UInt8 Base;
 
    enum Enum
    {
        Opening = 1,

        Standard = 2,

        Closing = 3
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT TradingSide
{
    typedef UInt8 Base;
 
    enum Enum
    {
        BidOnly = 1,

        OfferOnly = 2,

        PAKO = 3,

        BothSides = 4
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT PriceLimits
{
    typedef UInt8 Base;
 
    enum Enum
    {
        PriceLimitsEnabledNormal = 1,

        PriceLimitsEnabledWide = 2,

        PriceLimitsEnabledWidest = 3,

        PriceLimitsDisabled = 4
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT QuoteSpreadMultiplier
{
    typedef UInt8 Base;
 
    enum Enum
    {
        QuoteSpreadMultiplier1 = 1,

        QuoteSpreadMultiplier2 = 2,

        QuoteSpreadMultiplier3 = 3
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT ExchangeCode
{
    typedef Char Base;
 
    enum Enum
    {
        AmsterdamEquityDerivatives = 'A',

        BrusselsEquityDerivatives = 'B',

        ParisEquityUnderlyings = 'C',

        BrusselsCashUnderlyings = 'D',

        BrusselsIndexDerivatives = 'F',

        AmsterdamCashUnderlyings = 'G',

        LisbonCashUnderlyings = 'H',

        ParisIndexDerivatives = 'J',

        AmsterdamIndexDerivatives = 'K',

        LisbonIndexDerivatives = 'M',

        ParisEquityDerivatives = 'P',

        AmsterdamCommoditiesDerivatives = 'R',

        LisbonEquityDerivatives = 'S',

        ParisCommoditiesDerivatives = 'Y',

        AmsterdamCurrencyDerivatives = 'Z',

        OsloIndexDerivatives = 'N',

        OsloEquityDerivatives = 'O',

        OsloCashUnderlying = 'L',

        MilanCashUnderlying = 'U',

        MilanIndexDerivatives = 'I',

        MilanEquityDerivatives = 'E',

        MilanInterestRateDerivatives = 'T'
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT LegBuyorSell
{
    typedef Char Base;
 
    enum Enum
    {
        Buy = 'B',

        Sell = 'S'
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT OptiqSegment
{
    typedef UInt8 Base;
 
    enum Enum
    {
        Equities = 1,

        Funds = 2,

        FixedIncome = 3,

        WarrantsAndCertificates = 4,

        BourseDeLuxembourg = 5,

        Options = 6,

        Futures = 7,

        Commodities = 8,

        Indices = 9,

        TradeReportingAndPublication = 10,

        Block = 14,

        IndexDerivatives = 11,

        EquityDerivatives = 12,

        FinancialDerivatives = 13,

        Forex = 15,

        IBF = 16
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT OptionType
{
    typedef UInt8 Base;
 
    enum Enum
    {
        Call = 1,

        Put = 2,

        Other = 3
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT IndexLevelType
{
    typedef UInt8 Base;
 
    enum Enum
    {
        IndicativeIndex = 0,

        OfficialOpeningIndex = 1,

        RealTimeIndex = 2,

        AutomaticIndicativeIndex = 3,

        PreliminaryReferenceIndex = 4,

        ClosingReferenceIndex = 5,

        ConfirmedReferenceIndex = 6,

        OptionsLiquidationIndex = 7
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT TransactionType
{
    typedef UInt8 Base;
 
    enum Enum
    {
        PlainVanillaTrade = 1,

        DarkTrade = 2,

        BenchmarkTrade = 3,

        TechnicalTrade = 4,

        GiveupGiveinTrade = 5,

        ExCumDividendTrade = 6,

        TradeWithCondition = 7,

        SummaryReport = 15
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT BlockTradeCode
{
    typedef Char Base;
 
    enum Enum
    {
        BlockTrade = 'B',

        RegularTradeOrNegotiatedDeal = 'N',

        Undefined = '-'
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT EffectiveDateIndicator
{
    typedef UInt8 Base;
 
    enum Enum
    {
        SellerDeclarationIsReceivedOnTheCurTradingSessionDay = 0,

        SellerDeclarationReceivedBeforeTheCurTradingSessionDay = 1
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT IndexPriceCode
{
    typedef UInt8 Base;
 
    enum Enum
    {
        OnlyIndex = 0,

        IndexAndSessionHigh = 1,

        IndexAndSessionLow = 2,

        IndexAndSessionHighAndLowTypicallyFirstPrice = 3,

        OnlySessionHigh = 4,

        OnlySessionLow = 5,

        PreviousDayClose = 6
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT StatsUpdateType
{
    typedef UInt8 Base;
 
    enum Enum
    {
        DailyHigh = 5,

        DailyLow = 6,

        YearlyHigh = 7,

        YearlyLow = 8,

        LifetimeHigh = 9,

        LifetimeLow = 10,

        VariationLastPrice = 14,

        OpenPrice = 15,

        TradeCount = 16,

        LastTradedPrice = 17,

        PercentVariationPreviousClose = 18,

        OffBookCumulQty = 19,

        OnBookAuctionCumulQty = 21,

        OnBookContinuousCumulQty = 22,

        OnAndOffBookCumulQty = 23
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT GuaranteeIndicator
{
    typedef UInt8 Base;
 
    enum Enum
    {
        ThisInstrumentIsNotGuaranteed = 0,

        ThisInstrumentIsGuaranteed = 1,

        ThisInstrumentIsNotClearable = 2,

        GuaranteedClearedBorrowingLendingService = 8
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT MmtMarketMechanism
{
    typedef UInt8 Base;
 
    enum Enum
    {
        CentralLimitOrderBook = 1,

        QuoteDrivenMarket = 2,

        DarkOrderBook = 3,

        OffBookIncludingVoiceOrMessagingTrading = 4,

        PeriodicAuctionEqualUncrossing = 5,

        RequestForQuotes = 6,

        HybridSystem = 8,

        AnyOtherExcludingHybrid = 9
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT EfficientMMTMarketMechanism
{
    typedef UInt8 Base;
 
    enum Enum
    {
        CentralLimitOrderBook = 1,

        QuoteDrivenMarket = 2,

        DarkOrderBook = 3,

        OffBookIncludingVoiceOrMessagingTrading = 4,

        PeriodicAuctionEqualUncrossing = 5,

        RequestForQuotes = 6,

        Other = 7
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT MmtTradingMode
{
    typedef Char Base;
 
    enum Enum
    {
        UndefinedAuctionEqualUncrossing = '1',

        ContinuousTrading = '2',

        AtMarketCloseTrading = '3',

        OutOfMainSessionTrading = '4',

        TradeReportingOnExchange = '5',

        TradeReportingOffExchange = '6',

        TradeReportingSystematicInternaliser = '7',

        ScheduledIntradayAuctionEqualUncrossing = 'I',

        ScheduledClosingAuctionEqualUncrossing = 'K',

        ScheduledOpeningAuctionEqualUncrossing = 'O',

        UnscheduledAuctionEqualUncrossing = 'U',

        OnDemandAuctionEqualFrequentBatchedAuction = 'P'
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT EfficientMMTTradingMode
{
    typedef Char Base;
 
    enum Enum
    {
        UndefinedAuctionEqualUncrossing = '1',

        ContinuousTrading = '2',

        AtMarketCloseTrading = '3',

        OutOfMainSessionTrading = '4',

        TradeReportingOnExchange = '5',

        TradeReportingOffExchange = '6',

        TradeReportingSystematicInternaliser = '7',

        ScheduledIntradayAuctionEqualUncrossing = 'I',

        ScheduledClosingAuctionEqualUncrossing = 'K',

        ScheduledOpeningAuctionEqualUncrossing = 'O',

        UnscheduledAuctionEqualUncrossing = 'U',

        OnDemandAuctionEqualFrequentBatchedAuction = 'P'
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT EfficientMMTTransactionCategory
{
    typedef Char Base;
 
    enum Enum
    {
        DarkTrade = 'D',

        RPRI = 'R',

        XFPH = 'Y',

        TPAC = 'Z',

        NoneApply = '-'
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT EfficientMMTNegotiationIndicator
{
    typedef Char Base;
 
    enum Enum
    {
        NLIQ = '1',

        OILQ = '2',

        PRIC = '3',

        ILQD = '4',

        SIZE = '5',

        ILQDSIZE = '6',

        NegotiatedTrade = 'N',

        NoNegotiatedTrade = '-'
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT EfficientMMTAgencyCrossTradeIndicator
{
    typedef Char Base;
 
    enum Enum
    {
        ACTX = 'X',

        NoAgencyCrossTrade = '-'
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT EfficientMMTModificationIndicator
{
    typedef Char Base;
 
    enum Enum
    {
        AMND = 'A',

        CANC = 'C',

        NewTrade = '-'
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT EfficientMMTBenchmarkIndicator
{
    typedef Char Base;
 
    enum Enum
    {
        BENC = 'B',

        RFPT = 'S',

        NoBenchmarkOrReferencePriceTrade = '-'
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT EfficientMMTSpecialDividendIndicator
{
    typedef Char Base;
 
    enum Enum
    {
        SDIV = 'E',

        NoSpecialDividendTrade = '-'
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT MmtOffBookAutomatedIndicator
{
    typedef Char Base;
 
    enum Enum
    {
        OffBookNonAutomated = 'M',

        OffBookAutomated = 'Q',

        UnspecifiedOrDoesNotApply = '-'
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT EfficientMMTOffBookAutomatedIndicator
{
    typedef Char Base;
 
    enum Enum
    {
        OffBookNonAutomated = 'M',

        OffBookAutomated = 'Q',

        UnspecifiedOrDoesNotApply = '-'
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT EfficientMMTContributiontoPrice
{
    typedef Char Base;
 
    enum Enum
    {
        TNCP = 'J',

        PNDG = 'N',

        PlainVanillaTrade = 'P',

        NPFT = 'T'
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT EfficientMMTAlgorithmicIndicator
{
    typedef Char Base;
 
    enum Enum
    {
        ALGO = 'H',

        NoAlgorithmicTrade = '-'
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT EfficientMMTPublicationMode
{
    typedef Char Base;
 
    enum Enum
    {
        NonImmediatePublication = '1',

        LRGS = '2',

        ILQD = '3',

        SIZE = '4',

        ILQDSIZE = '5',

        ILQDLRGS = '6',

        ImmediatePublication = '-'
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT EfficientMMTPostTradeDeferral
{
    typedef Char Base;
 
    enum Enum
    {
        LMTF = '1',

        DATF = '2',

        VOLO = '3',

        FWAF = '4',

        IDAF = '5',

        VOLW = '6',

        FULF = '7',

        FULA = '8',

        FULV = '9',

        FULJ = 'V',

        COAF = 'W',

        NotApplicable = '-'
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT EfficientMMTDuplicativeIndicator
{
    typedef Char Base;
 
    enum Enum
    {
        DUPL = '1',

        UniqueTradeReport = '-'
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT TransparencyIndicator
{
    typedef UInt8 Base;
 
    enum Enum
    {
        LitRegularTrade = 0,

        DarkTradeAndImmediatePublication = 1,

        DarkTradeAndDeferredPublication = 2
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT MiFIDInstrumentCategory
{
    typedef UInt8 Base;
 
    enum Enum
    {
        NotApplicable = 0,

        RTS1EquityInstrumentFollowingMiFIDDefinition = 1,

        RTS2NonEquityInstrumentFollowingMiFIDDefinition = 2
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT DynamicCollarLogic
{
    typedef UInt8 Base;
 
    enum Enum
    {
        NotActive = 0,

        NoHaltWithReject = 2,

        HaltWithAcceptation = 3
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT ReferencePriceOrigin
{
    typedef UInt8 Base;
 
    enum Enum
    {
        Internal = 1,

        External = 2,

        ExternalBBO = 3,

        OpeningCallPrice = 4,

        MidBBOOrFairValue = 5,

        FairValue = 6,

        FutureMarketPrice = 7
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT TaxCode
{
    typedef UInt8 Base;
 
    enum Enum
    {
        NotEligibleToPEATheStockHasNeverBeenAMonoryStock = 0,

        EligibleToPEA = 3,

        NotProvided = 9
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT TypeOfMarketAdmission
{
    typedef Char Base;
 
    enum Enum
    {
        InstrumentsTradedOnThePrimaryMarket = 'A',

        InstrumentsTradedOnTheSecondaryMarket = 'B',

        InstrumentsTradedOnTheNewMarket = 'C',

        NonRegulatedMarketInstrumentsTradedOnTheFreeMarket = 'D',

        NonRegulatedMarketAlternext = 'E',

        NonListed = 'F',

        RegulatedMarketNonEquities = 'G',

        RegulatedMarketEquitiesSegmentA = 'H',

        RegulatedMarketEquitiesSegmentB = 'I',

        RegulatedMarketEquitiesSegmentC = 'J',

        RegulatedMarketAllSecuritiesSpecialSegment = 'K',

        RegulatedMarketEquitiesOtherInstruments = 'L',

        OPCVMSICOMINonListedFrenchInvestmentFunds = 'S',

        OffMarket = '6',

        GoldCurrenciesAndIndices = '7',

        Foreign = '9'
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT ExerciseStyle
{
    typedef UInt8 Base;
 
    enum Enum
    {
        European = 0,

        American = 1,

        Asian = 2,

        Bermudan = 3,

        Other = 4,

        Periodic = 5
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT ContractTradingType
{
    typedef UInt8 Base;
 
    enum Enum
    {
        NotApplicable = 0,

        TradedAsAnOutright = 1,

        NotTradedButListedInContractDataTradersMaySubscribeTo = 2,

        TradedAsASimpleIntercommoditySpread = 3,

        TradedAsAnIntercommoditySpread = 4
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT OpenedClosedFund
{
    typedef Char Base;
 
    enum Enum
    {
        Open = 'O',

        Closed = 'C'
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT GrossofCDSCIndicator
{
    typedef Char Base;
 
    enum Enum
    {
        No = 'N',

        Yes = 'Y'
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT PaymentFrequency
{
    typedef UInt8 Base;
 
    enum Enum
    {
        Annual = 1,

        SemiAnnual = 2,

        Quarterly = 3,

        Monthly = 4,

        BiMonthly = 5,

        Daily = 6,

        MigrationNA = 7,

        Other = 8,

        NoCoupon = 9,

        AtMaturity = 10,

        Triannual = 11,

        Capitalization = 12,

        IMMDates = 13,

        Bimestrial = 14,

        Weekly = 15
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT SecurityCondition
{
    typedef Char Base;
 
    enum Enum
    {
        Normal = 'O',

        ExDividend = 'D',

        ExCap = 'C',

        ExRights = 'R',

        ExEntitlement = 'E',

        DealingsTemporarilySuspended = 'S',

        NotListed = 'N'
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT TaxDescriptionAttachingtoaDividend
{
    typedef Char Base;
 
    enum Enum
    {
        DeducedAtSource = 'D'
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT TradingPolicy
{
    typedef UInt8 Base;
 
    enum Enum
    {
        PriceExplicitTime = 1,

        PriceProRata = 2
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT DerivativesMarketModel
{
    typedef UInt8 Base;
 
    enum Enum
    {
        NoSyntheticQuote = 0,

        SpontaneousImpliedMatching = 1,

        EventDrivenImpliedMatching = 2
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT DerivativesInstrumentType
{
    typedef UInt8 Base;
 
    enum Enum
    {
        CallOption = 0,

        PutOption = 1,

        Strategy = 2,

        IndividualFuture = 3,

        Underlying = 4
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT Anonymous
{
    typedef UInt8 Base;
 
    enum Enum
    {
        No = 0,

        Yes = 1
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT PriceQualifier
{
    typedef UInt8 Base;
 
    enum Enum
    {
        LastAdjustedClosingPrice = 1,

        LastTradedPrice = 2,

        VolumeWeightedAveragePrice = 3,

        ClosingUncrossingPrice = 4,

        ValuationPrice = 5,

        AverageOfBBO = 6,

        AverageOfBestBid = 7,

        UpdatedByMarketOperations = 8,

        ClosingPriceOfReferenceMarket = 9
    };

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

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT MmProtections
{
public:
    typedef UInt8 Bits;
 
    enum
    {
        Size = sizeof(Bits)
    };
 

    struct MemberTraits
    {
        enum { Count = 1 };
 
        typedef Bits FirstArgType;
    };

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool delta() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x1);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool volume() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x2);
    }

    Bits bits() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return bits_;
    }

    explicit
    MmProtections(Bits bits = 0)
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
      : bits_(bits)
    {
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    std::string
    toString() const;

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

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool
    operator==(
        const MmProtections& other) const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return this->bits_ == other.bits_;
    }
 
private:
    Bits bits_;
};

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT TradeQualifier
{
public:
    typedef UInt8 Bits;
 
    enum
    {
        Size = sizeof(Bits)
    };
 

    struct MemberTraits
    {
        enum { Count = 1 };
 
        typedef Bits FirstArgType;
    };

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool uncrossingTrade() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x1);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool firstTradePrice() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x2);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool passiveOrder() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x4);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool aggressiveOrder() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x8);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool tradeCreationByMarketOperations() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x10);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool navTradeExpressedInBps() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x20);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool navTradeExpressedInPriceCurrency() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x40);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool deferredPublication() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x80);
    }

    Bits bits() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return bits_;
    }

    explicit
    TradeQualifier(Bits bits = 0)
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
      : bits_(bits)
    {
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    std::string
    toString() const;

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

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool
    operator==(
        const TradeQualifier& other) const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return this->bits_ == other.bits_;
    }
 
private:
    Bits bits_;
};

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT PhaseQualifier
{
public:
    typedef UInt16 Bits;
 
    enum
    {
        Size = sizeof(Bits)
    };
 

    struct MemberTraits
    {
        enum { Count = 1 };
 
        typedef Bits FirstArgType;
    };

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool qualifier() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x1);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool callBBOOnly() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x2);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool tradingAtLast() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x4);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool randomUncrossing() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x8);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool suspended() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x10);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool wholesaleAllowed() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x20);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool stressedMarketConditions() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x40);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool exceptionalMarketConditions() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x80);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool quotingPeriod() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x200);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool executionPreventionAcrossAllFirms() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x400);
    }

    Bits bits() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return bits_;
    }

    explicit
    PhaseQualifier(Bits bits = 0)
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
      : bits_(bits)
    {
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    std::string
    toString() const;

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

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool
    operator==(
        const PhaseQualifier& other) const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return this->bits_ == other.bits_;
    }
 
private:
    Bits bits_;
};

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT StrategyAuthorized
{
public:
    typedef UInt64 Bits;
 
    enum
    {
        Size = sizeof(Bits)
    };
 

    struct MemberTraits
    {
        enum { Count = 1 };
 
        typedef Bits FirstArgType;
    };

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool jellyRoll() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x1);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool butterfly() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x2);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool callOrPutCabinet() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x4);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool spread() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x8);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool calendarSpread() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x10);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool diagonalCalendarSpread() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x20);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool guts() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x40);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool twoByOneRatioSpread() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x80);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool ironButterfly() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x100);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool combo() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x200);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool strangle() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x400);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool ladder() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x800);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool strip() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x1000);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool straddleCalendarSpread() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x2000);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool pack() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x4000);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool diagonalStraddleCalendarSpread() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x8000);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool simpleInterCommoditySpread() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x10000);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool conversionReversal() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x20000);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool straddle() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x40000);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool volatilityTrade() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x80000);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool condor() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x100000);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool box() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x200000);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool bundle() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x400000);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool reducedTickSpread() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x800000);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool ladderVersusUnderlying() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x1000000);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool butterflyVersusUnderlying() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x2000000);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool callSpreadVersusPutVersusUnderlying() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x4000000);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool callOrPutSpreadVersusUnderlying() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x8000000);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool callOrPutCalendarSpreadVersusUnderlying() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x10000000);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool callPutDiagonalCalendarSpreadVersusUnderlying() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x20000000);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool gutsVersusUnderlying() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x40000000);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool twoByOneCallOrPutRatioSpreadVersusUnderlying() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x80000000);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool ironButterflyVersusUnderlying() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x100000000);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool comboVersusUnderlying() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x200000000);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool strangleVersusUnderlying() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x400000000);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool exchangeForPhysical() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x800000000);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool straddleCalendarSpreadVersusUnderlying() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x1000000000);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool putSpreadVersusCallVersusUnderlying() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x2000000000);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool diagonalStraddleCalendarSpreadVersusUnderlying() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x4000000000);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool synthetic() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x8000000000);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool straddleVersusUnderlying() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x10000000000);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool condorVersusUnderlying() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x20000000000);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool buyWrite() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x40000000000);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool ironCondorVersusUnderlying() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x80000000000);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool ironCondor() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x100000000000);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool callSpreadVersusSellAPut() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x200000000000);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool putSpreadVersusSellACall() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x400000000000);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool putStraddleVersusSellACallOrAPut() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x800000000000);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool icsOneSidedCombinationSameExpiry() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x1000000000000);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool icsTwoSidedCombinationSameExpiry() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x2000000000000);
    }

    Bits bits() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return bits_;
    }

    explicit
    StrategyAuthorized(Bits bits = 0)
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
      : bits_(bits)
    {
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    std::string
    toString() const;

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

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool
    operator==(
        const StrategyAuthorized& other) const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return this->bits_ == other.bits_;
    }
 
private:
    Bits bits_;
};

ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT OrderTypeRules
{
public:
    typedef UInt16 Bits;
 
    enum
    {
        Size = sizeof(Bits)
    };
 

    struct MemberTraits
    {
        enum { Count = 1 };
 
        typedef Bits FirstArgType;
    };

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool market() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x1);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool limit() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x2);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool stopStopLoss() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x4);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool stopLimit() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x8);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool marketOnOpenMOO() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x10);
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool tradeAtSettlement() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return 0 != (bits_ & 0x20);
    }

    Bits bits() const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return bits_;
    }

    explicit
    OrderTypeRules(Bits bits = 0)
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
      : bits_(bits)
    {
    }

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    std::string
    toString() const;

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

    ONIXS_EURONEXT_OPTIQMDG_NODISCARD
    bool
    operator==(
        const OrderTypeRules& other) const
        ONIXS_EURONEXT_OPTIQMDG_NOTHROW
    {
        return this->bits_ == other.bits_;
    }
 
private:
    Bits bits_;
};
 

typedef
IntegralConstant<UInt8, 255>
NullUnsignedChar;
 

typedef
IntegralConstant<Int8, -128>
NullInt8;
 

typedef
IntegralConstant<UInt16, 65535>
NullUint16;
 

typedef
IntegralConstant<UInt32, 4294967295>
NullUint32;
 

typedef
IntegralConstant<UInt64, 18446744073709551615ULL>
NullUint64;
 

typedef
IntegralConstant<Int32, -2147483647-1>
NullInt32;
 

typedef
IntegralConstant<Int64, -9223372036854775807LL-1>
NullInt64;
 

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