SMP.Enumerations.h

Go to the documentation of this file.

#pragma once
/*
* 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.
*/


/*
--------------
GENERATED FILE
--------------
*/


#include <string> 


namespace OnixS {
namespace Mts {
namespace Repo {
namespace SDP {



struct ONIXS_MTS_REPO_SDP_API REPO_ACM_CASH_OFFER_EVENT
{
    enum Enum
    {
        /// Activate
        REPO_ACM_CASH_OFFER_EVENT_Activate,

        /// Suspend
        REPO_ACM_CASH_OFFER_EVENT_Suspend,

        /// Delete
        REPO_ACM_CASH_OFFER_EVENT_Delete,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API REPO_ACM_CASH_OFFER_STATUS
{
    enum Enum
    {
        /// Active
        REPO_ACM_CASH_OFFER_STATUS_Active,

        /// Suspended
        REPO_ACM_CASH_OFFER_STATUS_Suspended,

        /// Suspended By Governance
        REPO_ACM_CASH_OFFER_STATUS_SuspendedByGov,

        /// Suspended By System
        REPO_ACM_CASH_OFFER_STATUS_SuspendedBySys,

        /// Deleted
        REPO_ACM_CASH_OFFER_STATUS_Deleted,

        /// Out of Auction
        REPO_ACM_CASH_OFFER_STATUS_OutOfAuction,

        /// In Auction
        REPO_ACM_CASH_OFFER_STATUS_Executed,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API REPO_ACM_COLLATERAL_OFFER_EVENT
{
    enum Enum
    {
        /// Activate
        REPO_ACM_COLLATERAL_OFFER_EVENT_Activate,

        /// Suspend
        REPO_ACM_COLLATERAL_OFFER_EVENT_Suspend,

        /// Delete
        REPO_ACM_COLLATERAL_OFFER_EVENT_Delete,

        /// Accept
        REPO_ACM_COLLATERAL_OFFER_EVENT_Accept,

        /// Refuse
        REPO_ACM_COLLATERAL_OFFER_EVENT_Refuse,

        /// Refuse ECL
        REPO_ACM_COLLATERAL_OFFER_EVENT_RefuseECL,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API REPO_ACM_COLLATERAL_OFFER_STATUS
{
    enum Enum
    {
        /// Active
        REPO_ACM_COLLATERAL_OFFER_STATUS_Active,

        /// Processing
        REPO_ACM_COLLATERAL_OFFER_STATUS_Processing,

        /// Accepted
        REPO_ACM_COLLATERAL_OFFER_STATUS_Accepted,

        /// Suspended
        REPO_ACM_COLLATERAL_OFFER_STATUS_Suspended,

        /// Deleted
        REPO_ACM_COLLATERAL_OFFER_STATUS_Deleted,

        /// Suspended By Governance
        REPO_ACM_COLLATERAL_OFFER_STATUS_SuspendedByGov,

        /// Rejected By System
        REPO_ACM_COLLATERAL_OFFER_STATUS_RejectedBySys,

        /// Refused
        REPO_ACM_COLLATERAL_OFFER_STATUS_Refused,

        /// Refused ECL
        REPO_ACM_COLLATERAL_OFFER_STATUS_RefusedECL,

        /// TimeOut
        REPO_ACM_COLLATERAL_OFFER_STATUS_TimeOut,

        /// Out of Auction
        REPO_ACM_COLLATERAL_OFFER_STATUS_OutOfAuctio,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API REPO_ALGO_ID_REGISTRATION_EVENT
{
    enum Enum
    {
        /// Enable
        REPO_ALGO_ID_REGISTRATION_EVENT_Enable,

        /// Delete
        REPO_ALGO_ID_REGISTRATION_EVENT_Delete,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API REPO_ALGO_ID_REGISTRATION_STATUS
{
    enum Enum
    {
        /// Enabled
        REPO_ALGO_ID_REGISTRATION_STATUS_Enabled,

        /// Deleted
        REPO_ALGO_ID_REGISTRATION_STATUS_Deleted,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API REPO_ALGO_ID_TYPE
{
    enum Enum
    {
        /// Investment Decision
        REPO_ALGO_ID_TYPE_ID,

        /// Order Execution
        REPO_ALGO_ID_TYPE_OE,

        /// National ID
        REPO_ALGO_ID_TYPE_NI,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API REPO_ALGO_INFO_TYPE
{
    enum Enum
    {
        /// None
        REPO_ALGO_INFO_TYPE_None,

        /// Algo
        REPO_ALGO_INFO_TYPE_Algo,

        /// No Algo
        REPO_ALGO_INFO_TYPE_NoAlgo,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API REPO_CLIENT_REGISTRATION_EVENT
{
    enum Enum
    {
        /// Enable
        REPO_CLIENT_REGISTRATION_EVENT_Enable,

        /// Delete
        REPO_CLIENT_REGISTRATION_EVENT_Delete,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API REPO_CLIENT_REGISTRATION_STATUS
{
    enum Enum
    {
        /// Enabled
        REPO_CLIENT_REGISTRATION_STATUS_Enabled,

        /// Deleted
        REPO_CLIENT_REGISTRATION_STATUS_Deleted,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API REPO_CLIENT_IDENTIFICATION_TYPE
{
    enum Enum
    {
        /// None
        REPO_CLIENT_IDENTIFICATION_TYPE_None,

        /// LEI code
        REPO_CLIENT_IDENTIFICATION_TYPE_Lei,

        /// Aggregated Orders
        REPO_CLIENT_IDENTIFICATION_TYPE_Aggr,

        /// Pending Allocations
        REPO_CLIENT_IDENTIFICATION_TYPE_PnAl,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API REPO_CUTOFF_TYPE
{
    enum Enum
    {
        /// Trading
        REPO_CUTOFF_TYPE_Trading,

        /// CG Definition
        REPO_CUTOFF_TYPE_GC_Definition,

        /// All
        REPO_CUTOFF_TYPE_All,

        /// CG Trading
        REPO_CUTOFF_TYPE_GC_Trading,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API REPO_DATE_TYPE
{
    enum Enum
    {
        /// Start Date
        REPO_DATE_TYPE_StartDate,

        /// End Date
        REPO_DATE_TYPE_EndDate,

        /// Both
        REPO_DATE_TYPE_Both,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API REPO_DAY_COUNT
{
    enum Enum
    {
        /// 360
        REPO_DAY_COUNT_360,

        /// 365
        REPO_DAY_COUNT_365,

        /// Actual
        REPO_DAY_COUNT_ACTUAL,

        /// 366
        REPO_DAY_COUNT_366,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API REPO_FILL_TYPE
{
    enum Enum
    {
        /// None
        REPO_FILL_TYPE_None,

        /// BuySellBack
        REPO_FILL_TYPE_BuySellBack,

        /// Classic
        REPO_FILL_TYPE_Classic,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API REPO_FORCE_TYPE
{
    enum Enum
    {
        /// Never Forcing
        REPO_FORCE_TYPE_NeverForcing,

        /// Classic Repo Trade
        REPO_FORCE_TYPE_ClassicRepoTrade,

        /// BuySellBack
        REPO_FORCE_TYPE_BuySellBack,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API REPO_GC_BOND_DEFINITION_TYPE
{
    enum Enum
    {
        /// None
        REPO_GC_BOND_DEFINITION_TYPE_None,

        /// Optional
        REPO_GC_BOND_DEFINITION_TYPE_Optional,

        /// Mandatory
        REPO_GC_BOND_DEFINITION_TYPE_Mandatory,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API REPO_GC_TYPE
{
    enum Enum
    {
        /// None
        REPO_GC_TYPE_None,

        /// To Define
        REPO_GC_TYPE_ToDefine,

        /// Defined
        REPO_GC_TYPE_Defined,

        /// Locked
        REPO_GC_TYPE_Locked,

        /// Automatically Defined
        REPO_GC_TYPE_AutoDefined,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API REPO_HAIRCUT_EVENT
{
    enum Enum
    {
        /// Accept
        REPO_HAIRCUT_EVENT_Accept,

        /// Edit
        REPO_HAIRCUT_EVENT_Edit,

        /// Refuse
        REPO_HAIRCUT_EVENT_Refuse,

        /// Revoke
        REPO_HAIRCUT_EVENT_Revoke,

        /// Delete
        REPO_HAIRCUT_EVENT_Delete,

        /// Accept on behalf of FirstMember
        REPO_HAIRCUT_EVENT_AcceptFirstMember,

        /// Edit on behalf of FirstMember
        REPO_HAIRCUT_EVENT_EditFirstMember,

        /// Refuse on behalf of FirstMember
        REPO_HAIRCUT_EVENT_RefuseFirstMember,

        /// Revoke on behalf of FirstMember
        REPO_HAIRCUT_EVENT_RevokeFirstMember,

        /// Delete on behalf of FirstMember
        REPO_HAIRCUT_EVENT_DeleteFirstMember,

        /// Accept on behalf of SecondMember
        REPO_HAIRCUT_EVENT_AcceptSecondMember,

        /// Edit on behalf of SecondMember
        REPO_HAIRCUT_EVENT_EditSecondMember,

        /// Refuse on behalf of SecondMember
        REPO_HAIRCUT_EVENT_RefuseSecondMember,

        /// Revoke on behalf of SecondMember
        REPO_HAIRCUT_EVENT_RevokeSecondMember,

        /// Delete on behalf of SecondMember
        REPO_HAIRCUT_EVENT_DeleteSecondMember,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API REPO_HAIRCUT_STATUS
{
    enum Enum
    {
        /// Processing
        REPO_HAIRCUT_STATUS__Processing,

        /// Accepted
        REPO_HAIRCUT_STATUS__Accepted,

        /// Refused
        REPO_HAIRCUT_STATUS__Refused,

        /// Revoked
        REPO_HAIRCUT_STATUS__Revoked,

        /// Deleted
        REPO_HAIRCUT_STATUS__Deleted,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API REPO_HAIRCUT_TYPE
{
    enum Enum
    {
        /// Default
        REPO_HAIRCUT_TYPE__Default,

        /// Rfq
        REPO_HAIRCUT_TYPE__Rfq,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API REPO_MATCH_MODE
{
    enum Enum
    {
        /// Automatic
        REPO_MATCH_MODE_Automatic,

        /// Manual
        REPO_MATCH_MODE_Manual,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API REPO_MEMBER_ACCOUNT_TYPE
{
    enum Enum
    {
        /// None
        REPO_MEMBER_ACCOUNT_TYPE_None,

        /// CAP
        REPO_MEMBER_ACCOUNT_TYPE_CAP,

        /// COP
        REPO_MEMBER_ACCOUNT_TYPE_COP,

        /// RFCQ
        REPO_MEMBER_ACCOUNT_TYPE_RFCQ,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API REPO_MEMBER_GC_DEFAULT_STATUS
{
    enum Enum
    {
        /// Valid
        REPO_MEMBER_GC_DEFAULT_STATUS_Valid,

        /// Expired
        REPO_MEMBER_GC_DEFAULT_STATUS_Expired,

        /// Expiring
        REPO_MEMBER_GC_DEFAULT_STATUS_Expiring,

        /// Not Deliverable
        REPO_MEMBER_GC_DEFAULT_STATUS_NotDeliverable,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API REPO_NEGOTIATION_TYPE
{
    enum Enum
    {
        /// Special General
        REPO_NEGOTIATION_TYPE_SpecialGeneral,

        /// General
        REPO_NEGOTIATION_TYPE_General,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API REPO_OPEN_TRADE_EVENT
{
    enum Enum
    {
        /// Request for Closure
        REPO_OPEN_TRADE_EVENT_ClosureReq,

        /// Request for Rate Change
        REPO_OPEN_TRADE_EVENT_RateChangeReq,

        /// Request for Partial Closure
        REPO_OPEN_TRADE_EVENT_PartialClosureReq,

        /// Accept
        REPO_OPEN_TRADE_EVENT_Accept,

        /// Reject
        REPO_OPEN_TRADE_EVENT_Reject,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API REPO_OPEN_TRADE_STATUS
{
    enum Enum
    {
        /// Active
        REPO_OPEN_TRADE_STATUS_Active,

        /// Closed
        REPO_OPEN_TRADE_STATUS_Closed,

        /// Closed By System
        REPO_OPEN_TRADE_STATUS_ClosedBySystem,

        /// Locked
        REPO_OPEN_TRADE_STATUS_Locked,

        /// Cancelled
        REPO_OPEN_TRADE_STATUS_Cancelled,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API REPO_OPEN_TRADE_SUBSTATUS
{
    enum Enum
    {
        /// Undefined
        REPO_OPEN_TRADE_SUBSTATUS_Undefined,

        /// Closure Requested
        REPO_OPEN_TRADE_SUBSTATUS_ClosureRequested,

        /// Rate Change Requested
        REPO_OPEN_TRADE_SUBSTATUS_RateChangeReq,

        /// Partially Closure Requested
        REPO_OPEN_TRADE_SUBSTATUS_PartiallyCloseReq,

        /// Processing
        REPO_OPEN_TRADE_SUBSTATUS_Processing,

        /// Accepted
        REPO_OPEN_TRADE_SUBSTATUS_Accepted,

        /// Rejected
        REPO_OPEN_TRADE_SUBSTATUS_Rejected,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API REPO_ORDER_EVENT
{
    enum Enum
    {
        /// Insert
        REPO_ORDER_EVENT_Insert,

        /// Accept
        REPO_ORDER_EVENT_Accept,

        /// Refuse
        REPO_ORDER_EVENT_Refuse,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API REPO_ORDER_STATUS
{
    enum Enum
    {
        /// Processing
        REPO_ORDER_STATUS_Processing,

        /// Accepted
        REPO_ORDER_STATUS_Accepted,

        /// Refused
        REPO_ORDER_STATUS_Refused,

        /// Rejected by the system
        REPO_ORDER_STATUS_Rejected,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API REPO_ORDER_SUBSTATUS
{
    enum Enum
    {
        /// Processing
        REPO_ORDER_SUB_STATUS_Processing,

        /// Accepted
        REPO_ORDER_SUB_STATUS_Accepted,

        /// Exceeded Credit
        REPO_ORDER_SUB_STATUS_Exceed_Credit,

        /// Timeout
        REPO_ORDER_SUB_STATUS_Timeout,

        /// Cancelled
        REPO_ORDER_SUB_STATUS_Cancelled,

        /// Suspended by Governance
        REPO_ORDER_SUB_STATUS_Suspended,

        /// Cutoff
        REPO_ORDER_SUB_STATUS_Cutoff,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API REPO_ORDER_TYPE
{
    enum Enum
    {
        /// FAK
        REPO_ORDER_TYPE_Fak,

        /// FOK
        REPO_ORDER_TYPE_Fok,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API REPO_OTC_REGISTRATION_EVENT
{
    enum Enum
    {
        /// Insert
        REPO_OTC_REGISTRATION_EVENT_Insert,

        /// Accept
        REPO_OTC_REGISTRATION_EVENT_Accept,

        /// Refuse
        REPO_OTC_REGISTRATION_EVENT_Refuse,

        /// Accept on behalf of Originator
        REPO_OTC_REGISTRATION_EVENT_AcceptOriginator,

        /// Accept on behalf of Counterpart
        REPO_OTC_REGISTRATION_EVENT_AcceptCounterpart,

        /// Accept on behalf of both counterparts
        REPO_OTC_REGISTRATION_EVENT_AcceptBoth,

        /// Refuse on behalf of Originator
        REPO_OTC_REGISTRATION_EVENT_RefuseOriginator,

        /// Refuse on behalf of Counterpart
        REPO_OTC_REGISTRATION_EVENT_RefuseCounterpart,

        /// Cancel
        REPO_OTC_REGISTRATION_EVENT_Cancel,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API REPO_OTC_REGISTRATION_STATUS
{
    enum Enum
    {
        /// Processing
        REPO_OTC_REGISTRATION_STATUS_Processing,

        /// Accepted
        REPO_OTC_REGISTRATION_STATUS_Accepted,

        /// Refused
        REPO_OTC_REGISTRATION_STATUS_Refused,

        /// Locked
        REPO_OTC_REGISTRATION_STATUS_Locked,

        /// Cancelled by Governance
        REPO_OTC_REGISTRATION_STATUS_CancelledByGov,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API REPO_OTC_REGISTRATION_SUBSTATUS
{
    enum Enum
    {
        /// Processing
        REPO_OTC_REGISTRATION_SUBSTATUS_Processing,

        /// Accepted
        REPO_OTC_REGISTRATION_SUBSTATUS_Accepted,

        /// Refused
        REPO_OTC_REGISTRATION_SUBSTATUS_Refused,

        /// Accepted On Behalf
        REPO_OTC_REGISTRATION_SUBSTATUS_AcceptedOnBehalf,

        /// Refused On Behalf
        REPO_OTC_REGISTRATION_SUBSTATUS_RefusedOnBehalf,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API REPO_PERIOD
{
    enum Enum
    {
        /// Day
        REPO_PERIOD_Day,

        /// Week
        REPO_PERIOD_Week,

        /// Month
        REPO_PERIOD_Month,

        /// Year
        REPO_PERIOD_Year,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API REPO_PRICE_DOMAIN
{
    enum Enum
    {
        /// Any
        REPO_PRICE_DOMAIN_Any,

        /// Less 0
        REPO_PRICE_DOMAIN_LT_Zero,

        /// LessEqual 0
        REPO_PRICE_DOMAIN_LTE_Zero,

        /// Greater 0
        REPO_PRICE_DOMAIN_GT_Zero,

        /// Greater Eq 0
        REPO_PRICE_DOMAIN_GTE_Zero,

        /// Not Eq 0
        REPO_PRICE_DOMAIN_NE_Zero,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API REPO_PROP_EVENT
{
    enum Enum
    {
        /// Activate
        REPO_PROP_EVENT_Activate,

        /// Suspend
        REPO_PROP_EVENT_Suspend,

        /// Delete
        REPO_PROP_EVENT_Delete,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API REPO_PROP_STATUS
{
    enum Enum
    {
        /// Active
        REPO_PROP_STATUS_Active,

        /// Suspended
        REPO_PROP_STATUS_Suspended,

        /// Suspended By Governance
        REPO_PROP_STATUS_SuspendedByGov,

        /// Cancelled
        REPO_PROP_STATUS_Cancelled,

        /// Locked
        REPO_PROP_STATUS_Locked,

        /// Completely Filled
        REPO_PROP_STATUS_CompletelyFilled,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API REPO_REPO_CLASS
{
    enum Enum
    {
        /// BuySellBack
        REPO_REPO_CLASS_BuySellBack,

        /// Classic
        REPO_REPO_CLASS_Classic,

        /// Both
        REPO_REPO_CLASS_Both,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API REPO_RFCQ_ADDRESSEE_TYPE
{
    enum Enum
    {
        /// Single addressee
        REPO_RFCQ_ADDRESSEE_TYPE_Single,

        /// All sell side members
        REPO_RFCQ_ADDRESSEE_TYPE_All,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API REPO_RFCQ_COVER
{
    enum Enum
    {
        /// None
        REPO_RFCQ_COVER_None,

        /// AccT
        REPO_RFCQ_COVER_ACCT,

        /// Tied
        REPO_RFCQ_COVER_TIED,

        /// Cov
        REPO_RFCQ_COVER_COVR,

        /// CovT
        REPO_RFCQ_COVER_COVT,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API REPO_RFCQ_CREDIT_LINE_EVENT
{
    enum Enum
    {
        /// Enable
        REPO_RFCQ_CREDIT_LINE_EVENT_Enable,

        /// Disable
        REPO_RFCQ_CREDIT_LINE_EVENT_Disable,

        /// Delete
        REPO_RFCQ_CREDIT_LINE_EVENT_Delete,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API REPO_RFCQ_CREDIT_LINE_STATUS
{
    enum Enum
    {
        /// Enabled
        REPO_RFCQ_CREDIT_LINE_STATUS_Enabled,

        /// Disabled
        REPO_RFCQ_CREDIT_LINE_STATUS_Disabled,

        /// Deleted
        REPO_RFCQ_CREDIT_LINE_STATUS_Deleted,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API REPO_RFCQ_CREDIT_PROFILE
{
    enum Enum
    {
        /// Welcome
        REPO_RFCQ_CREDIT_PROFILE_Welcome,

        /// Unwelcome
        REPO_RFCQ_CREDIT_PROFILE__Unwelcome,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API REPO_RFCQ_ORDER_EVENT
{
    enum Enum
    {
        /// Insert
        REPO_ORDER_EVENT_Insert,

        /// Accept
        REPO_ORDER_EVENT_Accept,

        /// Refuse
        REPO_ORDER_EVENT_Refuse,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API REPO_RFCQ_SPREAD_CONFIGURATION_EVENT
{
    enum Enum
    {
        /// Insert
        REPO_RFCQ_SPREAD_CONFIGURATION_EVENT_Insert,

        /// Delete
        REPO_RFCQ_SPREAD_CONFIGURATION_EVENT_Delete,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API REPO_RFCQ_SPREAD_CONFIGURATION_STATUS
{
    enum Enum
    {
        /// Active
        REPO_RFCQ_SPREAD_CONFIGURATION_STATUS_Active,

        /// Deleted
        REPO_RFCQ_SPREAD_CONFIGURATION_STATUS_Deleted,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API REPO_RFCQ_WITHDRAW_TYPE
{
    enum Enum
    {
        /// Withdraw by trader
        REPO_RFCQ_WITHDRAW_TYPE_Trader,

        /// Withdraw by member
        REPO_RFCQ_WITHDRAW_TYPE_Member,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API REPO_SETTL_STATUS
{
    enum Enum
    {
        /// Undefined
        REPO_SETTL_STATUS_Undefined,

        /// Defined
        REPO_SETTL_STATUS_Defined,

        /// Error
        REPO_SETTL_STATUS_Error,

        /// Cancelled From Settlement
        REPO_SETTL_STATUS_CancelledFromSettlement,

        /// Waiting for Agent confirmation
        REPO_SETTL_STATUS_PendingAgent,

        /// Rejected by the Clearing Agent
        REPO_SETTL_STATUS_AgentRejected,

        /// Cancelled due to cutoff expiration
        REPO_SETTL_STATUS_LockedForCutoff,

        /// Error from Clearing House
        REPO_SETTL_STATUS_ErrorFromClearingHouse,

        /// Waiting from Clearing House
        REPO_SETTL_STATUS_WaitingFromClearingHouse,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_ACCOUNT_INFO_STATUS
{
    enum Enum
    {
        /// Accepted
        TI_ACCOUNT_INFO_STATUS_Accepted,

        /// Invalid
        TI_ACCOUNT_INFO_STATUS_Invalid,

        /// Refused
        TI_ACCOUNT_INFO_STATUS_Refused,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_ADDRESSEE_TYPE
{
    enum Enum
    {
        /// All Members Single Market
        TI_ADDRESSEE_TYPE_AllMembersSingleMarket,

        /// All Members Single Section
        TI_ADDRESSEE_TYPE_AllMembersSingleSection,

        /// Single Member All Markets
        TI_ADDRESSEE_TYPE_SingleMemberAllMarket,

        /// Profile Member Single Market
        TI_ADDRESSEE_TYPE_ProfileMemberSingleMarket,

        /// Profile Member Single Section
        TI_ADDRESSEE_TYPE_ProfileMemberSingleSection,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_ALLOCATION_TYPE
{
    enum Enum
    {
        /// Unspecified
        TI_ALLOCATION_TYPE_Unspecified,

        /// Single Account
        TI_ALLOCATION_TYPE_SingleAccount,

        /// Pre-Allocation
        TI__ALLOCATION__TYPE_PreAllocation,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_CHAT_REQUEST_EVENT
{
    enum Enum
    {
        /// Open
        TI_CHAT_REQUEST_EVENT_Open,

        /// Close
        TI_CHAT_REQUEST_EVENT_Close,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_CHAT_REQUEST_STATUS
{
    enum Enum
    {
        /// Opened
        TI_CHAT_REQUEST_STATUS_Opened,

        /// Closed
        TI_CHAT_REQUEST_STATUS_Closed,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_CREDIT_PROFILE
{
    enum Enum
    {
        /// Welcome
        TI_CREDIT_PROFILE_Welcome,

        /// Automatic
        TI_CREDIT_PROFILE_Automatic,

        /// Unwelcome
        TI_CREDIT_PROFILE_Unwelcome,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_EOI_ACTION
{
    enum Enum
    {
        /// New Message
        TI_EOI_ACTION_NewMessage,

        /// Respond
        TI_EOI_ACTION_Respond,

        /// Forward
        TI_EOI_ACTION_Forward,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_EOI_EVENT
{
    enum Enum
    {
        /// Activate
        TI_EOI_EVENT_Activate,

        /// Disable
        TI_EOI_EVENT_Disable,

        /// Cancel
        TI_EOI_EVENT_Cancel,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_EOI_STATUS
{
    enum Enum
    {
        /// Active
        TI_EOI_STATUS_Active,

        /// Disabled
        TI_EOI_STATUS_Disabled,

        /// Cancelled
        TI_EOI_STATUS_Cancellled,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_EOI_TYPE
{
    enum Enum
    {
        /// Generic
        TI_EOI_MSG_TYPE_Generic,

        /// EOI
        TI_EOI_MSG_TYPE_EOI,

        /// Announcement
        TI_EOI_MSG_TYPE_Announcement,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_EXEC_TREND
{
    enum Enum
    {
        /// Equal
        TI_EXEC_TREND_Equal,

        /// Less Than
        TI_EXEC_TREND_LessThan,

        /// Greater Than
        TI_EXEC_TREND_GreaterThan,

        /// Not Applicable
        TI_EXEC_TREND_NotApplicable,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_EXCEPTION_TYPE
{
    enum Enum
    {
        /// No Bonds Allowed
        TI_EXCEPTION_TYPE_NoBondsAllowed,

        /// Unseasoned Bonds Allowed
        TI_EXCEPTION_TYPE_UBondsAllowed,

        /// Unseasoned Bonds Not Allowed
        TI_EXCEPTION_TYPE_UBondsNotAllowed,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_FILL_STATUS
{
    enum Enum
    {
        /// Active
        TI_FILL_STATUS_Active,

        /// Cancelled
        TI_FILL_STATUS_Cancelled,

        /// Restored
        TI_FILL_STATUS_Restored,

        /// Cancelled - Split
        TI_FILL_STATUS_CancelledForSplit,

        /// Modified
        TI_FILL_STATUS_Modified,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_IN_OUT_FLAG
{
    enum Enum
    {
        /// Out
        TI_IN_OUT_FLAG_Out,

        /// In
        TI_IN_OUT_FLAG_In,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_LAST_DEAL_VERB
{
    enum Enum
    {
        /// Buy
        TI_LAST_DEAL_VERB_Buy,

        /// Sell
        TI_LAST_DEAL_VERB_Sell,

        /// None
        TI_LAST_DEAL_VERB_None,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_LIMIT_SPREAD_TYPE
{
    enum Enum
    {
        /// None
        TI_LIMIT_SPREAD_TYPE_None,

        /// Proceeds
        TI_LIMIT_SPREAD_TYPE_Proceeds,

        /// Gross Yield
        TI_LIMIT_SPREAD_TYPE_GrossYield,

        /// Risk Weight
        TI_LIMIT_SPREAD_TYPE_RiskWeightedYield,

        /// Proceeds Weight
        TI_LIMIT_SPREAD_TYPE_ProceedsWeightedYield,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_LINKED_QUOTE_STATUS
{
    enum Enum
    {
        /// Deleted
        TI_LINKED_QUOTE_STATUS_Deleted,

        /// Active
        TI_LINKED_QUOTE_STATUS_Active,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_MAIL_TYPE
{
    enum Enum
    {
        /// Member To Member
        TI_MAIL_TYPE_MemberToMember,

        /// Governance To Member
        TI_MAIL_TYPE_GovernanceToMember,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_MARKET_SIDE
{
    enum Enum
    {
        /// Bid
        TI_MARKET_SIDE_Bid,

        /// Ask
        TI_MARKET_SIDE_Ask,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_MASTER_AGREEMENT
{
    enum Enum
    {
        /// None
        TI_MASTER_AGREEMENT_NONE,

        /// ISDA
        TI_MASTER_AGREEMENT_ISDA,

        /// AFB/FBF
        TI_MASTER_AGREEMENT_AFB_FBF,

        /// DERV
        TI_MASTER_AGREEMENT_DERV,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_MEMBER_ACCOUNT_EVENT
{
    enum Enum
    {
        /// Insert
        TI_MEMBER_ACCOUNT_EVENT_Insert,

        /// Delete
        TI_MEMBER_ACCOUNT_EVENT_Delete,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_MEMBER_ACCOUNT_STATUS
{
    enum Enum
    {
        /// Active
        TI_MEMBER_ACCOUNT_STATUS_Active,

        /// Deleted
        TI__MEMBER_ACCOUNT_STATUS_Deleted,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_MEMBER_ACCOUNT_EXCEPTION_EVENT
{
    enum Enum
    {
        /// Insert
        TI_MEMBER_ACCOUNT_EXCEPTION_EVENT_Insert,

        /// Delete
        TI_MEMBER_ACCOUNT_EXCEPTION_EVENT_Delete,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_MEMBER_ACCOUNT_EXCEPTION_STATUS
{
    enum Enum
    {
        /// Active
        TI_MEMBER_ACCOUNT_EXCEPTION_STATUS_Active,

        /// Deleted
        TI_MEMBER_ACCOUNT_EXCEPTION_STATUS_Deleted,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_MEMBER_ACCOUNT_TYPE
{
    enum Enum
    {
        /// None
        TI_MEMBER_ACCOUNT_TYPE_None,

        /// CAP
        TI_MEMBER_ACCOUNT_TYPE_CAP,

        /// COP
        TI_MEMBER_ACCOUNT_TYPE_COP,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_MEMBER_TRADING_STATUS
{
    enum Enum
    {
        /// Trade Off. All market operations are allowed and the member proposals are not visible on the market.
        TI_MEMBER_TRADING_STATUS_TradeOff,

        /// Trade On. At least one trader has logged on: all market operations are allowed and the member proposals are visible on the market.
        TI_MEMBER_TRADING_STATUS_TradeOn,

        /// Suspended. Member suspended by the supervisory bodies: members operativeness is blocked until reactivation.
        TI_MEMBER_TRADING_STATUS_Suspended,

        /// Suspended Today. Member suspended by the supervisory bodies: members operativeness is blocked for the current trading day. Reserved for future use.
        TI_MEMBER_TRADING_STATUS_SuspendedToday,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_MESSAGE_RECIPIENT_TYPE
{
    enum Enum
    {
        /// Single
        TI_MESSAGE_RECIPIENT_TYPE_Single,

        /// All
        TI_MESSAGE_RECIPIENT_TYPE_All,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_MESSAGE_TXN_TYPE
{
    enum Enum
    {
        /// None
        TI_MESSAGE_TXN_TYPE_None,

        /// RFQ
        TI_MESSAGE_TXN_TYPE_RFQ,

        /// RFCQ
        TI_MESSAGE_TXN_TYPE_RFCQ,

        /// OTC
        TI_MESSAGE_TXN_TYPE_OTC,

        /// Chat
        TI_MESSAGE_TXN_TYPE_Chat,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_POSSIBLE_QUOTING
{
    enum Enum
    {
        /// None
        TI_POSSIBLE_QUOTING_None,

        /// Single Side (FAS Orders only)
        TI_POSSIBLE_QUOTING_Single,

        /// Double Side (Proposals Only)
        TI_POSSIBLE_QUOTING_Double,

        /// Both
        TI_POSSIBLE_QUOTING_Both,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_RELATION_LEVEL
{
    enum Enum
    {
        /// Member. The sales' customer is the member
        TI_RELATION_LEVEL_Member,

        /// Trader. The sales' customer is a trader of the member
        TI_RELATION_LEVEL_Trader,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_RELATION_TYPE
{
    enum Enum
    {
        /// Undefined.Undefined relationship type
        TI_RELATION_TYPE_Undefined,

        /// Primary. Primary relationship type
        TI_RELATION_TYPE_Primary,

        /// Secondary. Secondary relationship type
        TI_RELATION_TYPE_Secondary,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_RFCQ_EVENT
{
    enum Enum
    {
        /// Accept
        TI_RFCQ_EVENT_Accept,

        /// Refuse
        TI_RFCQ__EVENT_Refuse,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_RFCQ_EXCLUSION_EVENT
{
    enum Enum
    {
        /// Activate
        TI_RFCQ_EXCLUSION_EVENT_Activate,

        /// Suspend
        TI_RFCQ_EXCLUSION_EVENT_Suspend,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_RFCQ_EXCLUSION_STATUS
{
    enum Enum
    {
        /// Active
        TI_RFCQ_EXCLUSION_STATUS_Active,

        /// Suspend
        TI_RFCQ_EXCLUSION_EVENT_Suspend,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_RFCQ_MATCHING_TYPE
{
    enum Enum
    {
        /// Live
        TI_RFCQ_MATCHING_TYPE_Automatic,

        /// Subject
        TI_RFCQ__MATCHING_TYPE_Manual,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_RFCQ_INSTRUMENT_CLASS_ENABLE_EVENT
{
    enum Enum
    {
        /// Insert
        TI_RFCQ_INSTRUMENT_CLASS_ENABLE_EVENT_Insert,

        /// Delete
        TI_RFCQ_INSTRUMENT_CLASS_ENABLE_EVENT_Delete,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_RFCQ_INSTRUMENT_CLASS_ENABLE_STATUS
{
    enum Enum
    {
        /// Active
        TI_RFCQ_INSTRUMENT_CLASS_ENABLE_STATUS_Active,

        /// Deleted
        TI_RFCQ_INSTRUMENT_CLASS_ENABLE_STATUS_Deleted,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_RFCQ_ORDER_STATUS
{
    enum Enum
    {
        /// Pending.
        TI_RFCQ_ORDER_STATUS_Processing,

        /// Reject
        TI_RFCQ_ORDER_STATUS_Refused,

        /// Reject
        TI_RFCQ_ORDER_STATUS_RFCQRefused,

        /// Done - Auto
        TI_RFCQ_ORDER_STATUS_CompletelyFilled,

        /// Done - Manual
        TI_RFCQ_ORDER_STATUS_ManuallyCompletelyFilled,

        /// Partialy Filled. Reserved for future use
        TI_RFCQ_ORDER_STATUS_PartiallyFilled,

        /// Zero Filled
        TI_RFCQ_ORDER_STATUS_ZeroFilled,

        /// Expired
        TI_RFCQ_ORDER_STATUS_RefusedForRFCQTimeout,

        /// Timeout
        TI_RFCQ_ORDER_STATUS_RefusedForAcceptanceTimeout,

        /// Reject by System
        TI_RFCQ_ORDER_STATUS_RefusedBySystem,

        /// Reject by Gov.nce
        TI_RFCQ_ORDER_STATUS_DeletedByGovernance,

        /// Reject Order Suspend
        TI_RFCQ_ORDER_STATUS_DeletedForSuspension,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_RFCQ_ORDER_TYPE
{
    enum Enum
    {
        /// At Best - Selected Dealer
        TI_RFCQ_ORDER_TYPE_Normal,

        /// At Best
        TI_RFCQ_ORDER_TYPE_BestPrice,

        /// At Best Proceeds. Reversed for future use.
        TI_RFCQ_ORDER_TYPE_BestProceeds,

        /// At Best Gross Yield. Reserved for future use.
        TI_RFCQ_ORDER_TYPE_BestGrossYield,

        /// At Best Risk Weight. Reserved for future use.
        TI_RFCQ_ORDER_TYPE_BestRiskWeightedYield,

        /// At Best Proceeds Weight. Reserved For future use.
        TI_RFCQ_ORDER_TYPE_BestProceedsWeightedYield,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_RFCQ_ORIGIN
{
    enum Enum
    {
        /// From Scratch
        TI_RFCQ_ORIGIN_FromScratch,

        /// From Single Dealer Page
        TI_RFCQ_ORIGIN_FromDealer,

        /// From Inventory
        TI_RFCQ_ORIGIN_FromInventory,

        /// From Implied Price (STF Market Only)
        TI_RFCQ_ORIGIN_FromImpliedPrice,

        /// From Firm Book
        TI_RFCQ_ORIGIN_FromFirmBook,

        /// From Indicative Book
        TI_RFCQ_ORIGIN_FromIndicativeBook,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_RFCQ_PROVIDER_STATUS
{
    enum Enum
    {
        /// Pending
        TI_RFCQ_PROVIDER_STATUS_Processing,

        /// Quote
        TI_RFCQ_PROVIDER_STATUS_Quoting,

        /// Done
        TI_RFCQ_PROVIDER_STATUS_Accepted,

        /// DAW
        TI_RFCQ_PROVIDER_STATUS_Matched,

        /// Reject by Client
        TI_RFCQ_PROVIDER_STATUS_Closed,

        /// Reject by Dealer
        TI_RFCQ_PROVIDER_STATUS_Refused,

        /// Expired
        TI_RFCQ_PROVIDER_STATUS_Timeout,

        /// Stop by Gov.nce
        TI_RFCQ_PROVIDER_STATUS_DeletedByGovernance,

        /// Invalid Dealer
        TI_RFCQ_PROVIDER_STATUS_InvalidMember,

        /// Dealer not online
        TI_RFCQ_PROVIDER_STATUS_Disconnected,

        /// Dealer not enabled
        TI_RFCQ_PROVIDER_STATUS_NoTradingRelation,

        /// Invalid Account
        TI_RFCQ_PROVIDER_STATUS_InvalidAccount,

        /// Invalid Settl Date
        TI_RFCQ_PROVIDER_STATUS_InvalidSettlDate,

        /// Dealer Suspended
        TI_RFCQ_PROVIDER_STATUS_ClosedByGovernance,

        /// Dealer Not enabled
        TI_RFCQ_PROVIDER_STATUS_MemberNotEnabled,

        /// Reject by Dealer
        TI_RFCQ_PROVIDER_STATUS_RefusedToQuote,

        /// Quote
        TI_RFCQ_PROVIDER_STATUS_Quoted,

        /// Done
        TI_RFCQ_PROVIDER_STATUS_Winner,

        /// Reject by System
        TI_RFCQ_PROVIDER_STATUS_ClosedBySystem,

        /// Function not enabled
        TI_RFCQ_PROVIDER_STATUS_DisabledRfcqType,

        /// Unseasoned not enabled (CMF and BV Markets)
        TI_RFCQ_PROVIDER_STATUS_UnseasonedNotEnabled,

        /// Dealer Not enabled to Partial Fill
        TI_RFCQ_PROVIDER_STATUS_DisablePartialFill,

        /// Invalid Proposal Id (REPO Market Only)
        TI_RFCQ_PROVIDER_STATUS_InvalidProposalId,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_RFCQ_QUANTITY_CALCULATION
{
    enum Enum
    {
        /// User Input
        TI_RFCQ_QUANTITY_CALCULATION_UserInput,

        /// Risk
        TI_RFCQ_QUANTITY_CALCULATION_Risk,

        /// Modified Duration
        TI_RFCQ_QUANTITY_CALCULATION_ModifiedDuration,

        /// Proceeds
        TI_RFCQ_QUANTITY_CALCULATION_Proceeds,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_RFCQ_QUOTE_EVENT
{
    enum Enum
    {
        /// Activate
        TI_RFCQ_QUOTE_EVENT_Activate,

        /// Suspend
        TI_RFCQ_QUOTE_EVENT_Suspend,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_RFCQ_QUOTE_STATUS
{
    enum Enum
    {
        /// Active
        TI_RFCQ_QUOTE_STATUS_Active,

        /// Suspended
        TI_RFCQ_QUOTE_STATUS_Suspended,

        /// Deleted by Gov.nce
        TI_RFCQ_QUOTE_STATUS_DeletedByGovernance,

        /// Done - Auto
        TI_RFCQ_QUOTE_STATUS_CompletelyFilled,

        /// Done - Manual
        TI_RFCQ_QUOTE_STATUS_ManuallyCompletelyFilled,

        /// Pending Acceptance
        TI_RFCQ_QUOTE_STATUS_Locked,

        /// Deleted
        TI_RFCQ_QUOTE_STATUS_Deleted,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_RFCQ_REQUEST_EVENT
{
    enum Enum
    {
        /// Insert
        TI_RFCQ_REQUEST_EVENT_Insert,

        /// Close
        TI_RFCQ_REQUEST_EVENT_Close,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_RFCQ_REQUEST_STATUS
{
    enum Enum
    {
        /// Pending
        TI_RFCQ_REQUEST_STATUS_Processing,

        /// Done
        TI_RFCQ_REQUEST_STATUS_Accepted,

        /// Expired
        TI_RFCQ_REQUEST_STATUS_LifeTimeout,

        /// Closed by Client
        TI_RFCQ_REQUEST_STATUS_Closed,

        /// Reject by All
        TI_RFCQ_REQUEST_STATUS_RefusedByAll,

        /// Expired
        TI_RFCQ_REQUEST_STATUS_RejectedBySystem,

        /// Reject by Gov.nce
        TI_RFCQ_REQUEST_STATUS_ClosedByGovernance,

        /// Reject by System
        TI_RFCQ_REQUEST_STATUS_ClosedBySystem,

        /// Stop by Gov.nce
        TI_RFCQ_REQUEST_STATUS_DeletedByGovernance,

        /// DAW (Audit Trail Summary Only)
        TI_RFCQ_REQUEST_STATUS_Matched,

        /// Partially Accepted (Only for Double Sided RFCQ and MultiLeg RFCQ).
        TI_RFCQ_REQUEST_STATUS_PartiallyAccepted,

        /// Waiting for start (CMF and BV Markets - Only for MultiLeg RFCQ). Due In Time (STF Market)
        TI_RFCQ_REQUEST_STATUS_WaitingForStart,

        /// Not Tradable
        TI_RFCQ_REQUEST_STATUS_NotTradable,

        /// Closed By Sponsor (STF Market Only)
        TI_RFCQ_REQUEST_STATUS_ClosedBySponsor,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_RFCQ_STATUS
{
    enum Enum
    {
        /// Pending
        TI_RFCQ_STATUS_Processing,

        /// Live
        TI_RFCQ_STATUS_Quoting,

        /// Done
        TI_RFCQ_STATUS_Accepted,

        /// DAW
        TI_RFCQ__STATUS_Matched,

        /// Closed by Client
        TI_RFCQ_STATUS_Closed,

        /// Reject by Dealer
        TI_RFCQ__STATUS_Refused,

        /// Expired
        TI_RFCQ__STATUS_LifeTimeout,

        /// Reject by Gov.nce
        TI_RFCQ__STATUS_ClosedByGovernance,

        /// Reject by System
        TI_RFCQ__STATUS_ClosedBySystem,

        /// Done (Only for Double Sided RFCQ and MultiLeg RFCQ)
        TI_RFCQ_STATUS_PartiallyAccepted,

        /// Stop by Gov.nce (Only for Double Sided RFCQ and MultiLeg RFCQ)
        TI_RFCQ_STATUS_DeletedByGovernance,

        /// Due In Time (Only for MultiLeg RFCQ)
        TI_RFCQ_STATUS_WaitingForStart,

        /// Trading Not Enabled (Only for MultiLeg RFCQ)
        TI_RFCQ_STATUS_TradingNotEnabled,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_RFCQ_TRADING_LIST_EVENT
{
    enum Enum
    {
        /// Insert
        TI_RFCQ_TRADING_LIST_EVENT_Insert,

        /// Update
        TI_RFCQ_TRADING_LIST_EVENT__Update,

        /// Delete
        TI_RFCQ_TRADING_LIST_EVENT__Delete,

        /// Lock
        TI_RFCQ_TRADING_LIST_EVENT__Lock,

        /// Unlock
        TI_RFCQ_TRADING_LIST_EVENT__Unlock,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_RFCQ_TRADING_LIST_STATUS
{
    enum Enum
    {
        /// Active
        TI_RFCQ_TRADING_LIST_STATUS_Active,

        /// Deleted
        TI_RFCQ_TRADING_LIST_STATUS__Deleted,

        /// Error
        TI_RFCQ_TRADING_LIST_STATUS_Error,

        /// Locked
        TI_RFCQ_TRADING_LIST_STATUS_Locked,

        /// Processing
        TI_RFCQ_TRADING_LIST_STATUS__Processing,

        /// Done
        TI_RFCQ_TRADING_LIST_STATUS__Done,

        /// Deleted by Gov.nce
        TI_RFCQ_TRADING_LIST_STATUS_DeletedByGovernance,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_RFCQ_TRADING_RELATION_EXCEPTION_EVENT
{
    enum Enum
    {
        /// Insert
        TI_RFCQ_TRADING_RELATION_EXCEPTION_EVENT_Insert,

        /// Delete
        TI_RFCQ_TRADING_RELATION_EXCEPTION_EVENT_Delete,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_RFCQ_TRADING_RELATION_EXCEPTION_STATUS
{
    enum Enum
    {
        /// Active
        TI_RFCQ_TRADING_RELATION_EXCEPTION_STATUS_Active,

        /// Deleted
        TI_RFCQ_TRADING_RELATION_EXCEPTION_STATUS_Deleted,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_RFCQ_TRADING_RELATION_EVENT
{
    enum Enum
    {
        /// Accept
        TI_RFCQ_TRADING_RELATION_EVENT_Accept,

        /// Refuse
        TI_RFCQ_TRADING_RELATION_EVENT_Refuse,

        /// Revoke
        TI_RFCQ_TRADING_RELATION_EVENT_Revoke,

        /// Reset
        TI_RFCQ_TRADING_RELATION_EVENT_Reset,

        /// Delete (for Governance profile only)
        TI_RFCQ_TRADING_RELATION_EVENT_Delete,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_RFCQ_TRADING_RELATION_STATUS
{
    enum Enum
    {
        /// Processing
        TI_RFCQ_TRADING_RELATION_STATUS_Processing,

        /// Accepted
        TI_RFCQ_TRADING_RELATION_STATUS_Accepted,

        /// Revoked
        TI_RFCQ_TRADING_RELATION_STATUS_Revoked,

        /// Refused
        TI_RFCQ_TRADING_RELATION_STATUS_Refused,

        /// Deleted by Gov.nce
        TI_RFCQ_TRADING_RELATION_STATUS_DeletedByGovernance,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_RFCQ_TYPE
{
    enum Enum
    {
        /// Outright
        TI_RFCQ_TYPE_Outright,

        /// Switch
        TI_RFCQ_TYPE_Switch,

        /// Butterfly-classic
        TI_RFCQ_TYPE_Butterfly,

        /// MultiLeg
        TI_RFCQ_TYPE_MultiLeg,

        /// Butterfly-free
        TI_RFCQ_TYPE_ButterflyFree,

        /// Double Sided
        TI_RFCQ_TYPE_DoubleSided,

        /// All RFCQ
        TI_RFCQ_TYPE_AllRFCQ,

        /// Inventory Order
        TI_RFCQ_TYPE_InventoryOrder,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_RFCQ_TYPE_EXCEPTION_EVENT
{
    enum Enum
    {
        /// Insert
        TI_RFCQ_TYPE_EXCEPTION_EVENT_Insert,

        /// Delete
        TI_RFCQ_TYPE_EXCEPTION_EVENT_Delete,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_RFCQ_TYPE_EXCEPTION_STATUS
{
    enum Enum
    {
        /// Active
        TI_RFCQ_TYPE_EXCEPTION_STATUS_Active,

        /// Deleted
        TI_RFCQ_TYPE_EXCEPTION_STATUS_Deleted,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_RFQ_EVENT
{
    enum Enum
    {
        /// Insert
        TI_RFQ_EVENT_Insert,

        /// Accept
        TI_RFQ_EVENT_Accept,

        /// Refuse
        TI_RFQ_EVENT_Refuse,

        /// Respond
        TI_RFQ_EVENT_Respond,

        /// Cancel (REPO Market Only)
        TI_RFQ_EVENT_Cancel,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_RFQ_EXCLUSION_EVENT
{
    enum Enum
    {
        /// Activate
        TI_RFQ_EXCLUSION_EVENT_Activate,

        /// Suspend
        TI_RFQ_EXCLUSION_EVENT_Suspend,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_RFQ_EXCLUSION_STATUS
{
    enum Enum
    {
        /// Active
        TI_RFQ_EXCLUSION_STATUS_Active,

        /// Suspended
        TI_RFQ_EXCLUSION_STATUS_Suspended,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_RFQ_SETTING_TYPE
{
    enum Enum
    {
        /// Both
        TI_RFQ_SETTING_TYPE_Both,

        /// Only Price/Yield/Rate
        TI_RFQ_SETTING_TYPE_OnlyPrice,

        /// Only Quantity
        TI_RFQ_SETTING_TYPE_OnlyQty,

        /// None. Reserved for future use.
        TI_RFQ_SETTING_TYPE_None,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_RFQ_STATUS
{
    enum Enum
    {
        /// Processing
        TI_RFQ_STATUS_Processing,

        /// Accepted
        TI_RFQ_STATUS_Accepted,

        /// Refused
        TI_RFQ_STATUS_Refused,

        /// Rejected by the system
        TI_RFQ_STATUS_Rejected,

        /// Life Time Out
        TI_RFQ_STATUS_LifeTimeOut,

        /// Cancelled (for REPO market only)
        TI_RFQ_STATUS_Cancelled,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_RFQ_SUBSTATUS
{
    enum Enum
    {
        /// Processing
        TI_RFQ_SUBSTATUS_Processing,

        /// Accepted
        TI_RFQ_SUBSTATUS_Accepted,

        /// Refused
        TI_RFQ_SUBSTATUS_Refused,

        /// Timeout
        TI_RFQ_SUBSTATUS_Timeout,

        /// Cancelled
        TI_RFQ_SUBSTATUS_Cancelled,

        /// Suspended by Governance
        TI_RFQ_SUBSTATUS_Suspended,

        /// Cut Off
        TI_RFQ_SUBSTATUS_CutOff,

        /// Responded
        TI_RFQ_SUBSTATUS_Responded,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_STATISTIC_TYPE
{
    enum Enum
    {
        /// Life. Statistics refer to the trades made during the entire life of a product (For future use)
        TI_STATISTIC_TYPE_Life,

        /// Yesterday. Statistics refer to the trades made during the last trade day concluded
        TI_STATISTIC_TYPE_Yesterday,

        /// Today. Statistics refer to the trades made during the current trade day
        TI_STATISTIC_TYPE_Today,

        /// Hour. Statistics refer to the trades made at the specified hour of the current trade day
        TI_STATISTIC_TYPE_Hour,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_TRADE_TYPE
{
    enum Enum
    {
        /// Normal
        TI_TRADE_TYPE_Normal,

        /// RFQ
        TI_TRADE_TYPE_RFQ,

        /// RFCQ
        TI_TRADE_TYPE_RFCQ,

        /// OTC
        TI_TRADE_TYPE_OTC,

        /// Mid Price Crossing
        TI_TRADE_TYPE_MPC,

        /// Inventory Order
        TI_TRADE_TYPE_IO,

        /// Undefined
        TI_TRADE_TYPE_Undefined,

        /// Triparty Auction (REPO/ACM Market)
        TI_TRADE_TYPE_ACM,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_TRADER_TRADING_STATUS
{
    enum Enum
    {
        /// Logoff
        TI_TRADER_TRADING_STATUS_LogOff,

        /// Trader active. His proposals are visible on the market.
        TI_TRADER_TRADING_STATUS_Active,

        /// Trader suspended. His proposals are not visible on the market.
        TI_TRADER_TRADING_STATUS_Suspended,

        /// FastMarket. SWAP Market Only. Fast Market Status. Is used by the trader to modify the quote type of his own quotes from Normal to Indicative (Automatic).
        TI_TRADER_TRADING_STATUS_FastMarket,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_TRADING_CAPS_EVENT
{
    enum Enum
    {
        /// Enable
        TI_TRADING_CAPS_EVENT_Enable,

        /// Disable
        TI_TRADING_CAPS_EVENT_Disable,

        /// Delete
        TI_TRADING_CAPS_EVENT_Delete,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_TRADING_CAPS_FUNCTION
{
    enum Enum
    {
        /// Firm quote
        TI_TRADING_CAPS_FUNCTION_FirmQuote,

        /// FAS orders
        TI_TRADING_CAPS_FUNCTION_FASOrders,

        /// FAK/AON orders
        TI_TRADING_CAPS_FUNCTION_Orders,

        /// RFQ Send
        TI_TRADING_CAPS_FUNCTION_RFQSend,

        /// RFQ Respond
        TI_TRADING_CAPS_FUNCTION_RFQRespond,

        /// RFCQ Send
        TI_TRADING_CAPS_FUNCTION_RFCQSend,

        /// RFCQ Respond
        TI_TRADING_CAPS_FUNCTION_RFCQRespond,

        /// MultiLeg RFCQ Send
        TI_TRADING_CAPS_FUNCTION_MultiLegRFCQSend,

        /// MultiLeg RFCQ Respond
        TI_TRADING_CAPS_FUNCTION_MultiLegRFCQRespond,

        /// Not Used
        TI_TRADING_CAPS_FUNCTION_NotUsed,

        /// Inventory quote
        TI_TRADING_CAPS_FUNCTION_InventoryQuote,

        /// Stage Orders
        TI_TRADING_CAPS_FUNCTION_StageOrders,

        /// Split Fill
        TI_TRADING_CAPS_FUNCTION_SplitFill,

        /// Striker firm quote
        TI_TRADING_CAPS_FUNCTION_StrikerFirmQuote,

        /// Striker FAS order
        TI_TRADING_CAPS_FUNCTION_StrikerFASOrder,

        /// Mid price FAS order
        TI_TRADING_CAPS_FUNCTION_MidPriceFASOrder,

        /// Mid price FOK order
        TI_TRADING_CAPS_FUNCTION_MidPriceFOKOrder,

        /// Inventory order send
        TI_TRADING_CAPS_FUNCTION_InventoryOrderSend,

        /// Inventory order respond
        TI_TRADING_CAPS_FUNCTION_InventoryOrderRespond,

        /// All Bondvision Functions
        TI_TRADING_CAPS_FUNCTION_AllBVFunctions,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_TRADING_CAPS_MODALITY
{
    enum Enum
    {
        /// Maturity Adjusted
        TI_TRADING_CAPS_MODALITY_MaturityAdjusted,

        /// Nominal
        TI_TRADING_CAPS_MODALITY_Nominal,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_TRADING_CAPS_MODALITY_SETTING
{
    enum Enum
    {
        /// Currency
        TI_TRADING_CAPS_MODALITY_SETTING_Currency,

        /// Currency Equivalent
        TI_TRADING_CAPS_MODALITY_SETTING_CurrencyEquivalent,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_TRADING_CAPS_STATUS
{
    enum Enum
    {
        /// Enabled
        TI_TRADING_CAPS_STATUS_Enabled,

        /// Disabled
        TI_TRADING_CAPS_STATUS_Disabled,

        /// Deleted
        TI_TRADING_CAPS_STATUS_Deleted,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_TXN_TYPE
{
    enum Enum
    {
        /// Quote. Single side quote on SWAP market, double side quote on CMF, BV, STF markets and proposal on REPO market
        TI_TXN_TYPE_Quote,

        /// Order. 2 - TI_TXN_TYPE_Rfq
        TI_TXN_TYPE_Order,

        /// FAS Order. Used only on CMF market
        TI_TXN_TYPE_FasOrder,

        /// RFCQ. Used only on CMF, BV, STF markets
        TI_TXN_TYPE_Rfcq,

        /// RFCQ Order. Used only on CMF, BV, STF markets
        TI_TXN_TYPE_RfcqOrder,

        /// RFCQ Quote. Used only on CMF, BV, STF markets
        TI_TXN_TYPE_RfcqQuote,

        /// OTC. Used only on REPO market
        TI_TXN_TYPE_OTC,

        /// Mid Price FAS Order. Used only on CMF market
        TI_TXN_TYPE_MidPriceFASOrder,

        /// Mid Price FOK Order. Used only on CMF market
        TI__TXN_TYPE_MidPriceFOKOrder,

        /// Inventory Order. Used only on CMF and BV markets
        TI__TXN_TYPE_InventoryOrder,

        /// Auction Cash Offer. Used only on REPO market
        TI__TXN_TYPE_CashOffer,

        /// Auction Collateral Offer. Used only on REPO/ACM market
        TI__TXN_TYPE_CollateralOffer,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_VERB
{
    enum Enum
    {
        /// Buy
        TI_VERB_Buy,

        /// Sell
        TI_VERB_Sell,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_ACCESS_RIGHT
{
    enum Enum
    {
        /// None
        TI_ACCESS_RIGHT_None,

        /// Read
        TI_ACCESS_RIGHT_Read,

        /// Read and Write
        TI_ACCESS_RIGHT_ReadWrite,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_ALTERNATIVE_CODE_TYPE
{
    enum Enum
    {
        /// BLOOMBERG
        TI_ALTERNATIVE_CODE_TYPE_BLOOMBERG,

        /// CUSIP
        TI_ALTERNATIVE_CODE_TYPE_CUSIP,

        /// G.C.
        TI_ALTERNATIVE_CODE_TYPE_GC,

        /// ISIN
        TI_ALTERNATIVE_CODE_TYPE_ISIN,

        /// NO CODE
        TI_ALTERNATIVE_CODE_TYPE_NOCODE,

        /// REUTERS
        TI_ALTERNATIVE_CODE_TYPE_REUTERS,

        /// MARKIT
        TI_ALTERNATIVE_CODE_TYPE_MARKIT,

        /// TELEKURS
        TI_ALTERNATIVE_CODE_TYPE_TELEKURS,

        /// WKN
        TI_ALTERNATIVE_CODE_TYPE_WKN,

        /// AUSTRALIAN
        TI_ALTERNATIVE_CODE_TYPE_AUSTRALIAN,

        /// AUSTRIAN
        TI_ALTERNATIVE_CODE_TYPE_AUSTRIAN,

        /// BBEQID
        TI_ALTERNATIVE_CODE_TYPE_BBEQID,

        /// BBGID
        TI_ALTERNATIVE_CODE_TYPE_BBGID,

        /// COMMON
        TI_ALTERNATIVE_CODE_TYPE_COMMON,

        /// EURO COM
        TI_ALTERNATIVE_CODE_TYPE_EURO_COM,

        /// HONG KONG
        TI_ALTERNATIVE_CODE_TYPE_HONG_KONG,

        /// ITALY
        TI_ALTERNATIVE_CODE_TYPE_ITALY,

        /// JAPAN
        TI_ALTERNATIVE_CODE_TYPE_JAPAN,

        /// JPN SHRT
        TI_ALTERNATIVE_CODE_TYPE_JPN_SHRT,

        /// MALAYSIAN
        TI_ALTERNATIVE_CODE_TYPE_MALAYSIAN,

        /// Misc Dom
        TI_ALTERNATIVE_CODE_TYPE_MISC_DOM,

        /// MLNUM
        TI_ALTERNATIVE_CODE_TYPE_MLNUM,

        /// Pre Common
        TI_ALTERNATIVE_CODE_TYPE_PRE_COMMON,

        /// Pre ISIN
        TI_ALTERNATIVE_CODE_TYPE_PRE_ISIN,

        /// Pre Sedol
        TI_ALTERNATIVE_CODE_TYPE_PRE_SEDOL,

        /// SEDOL_1
        TI_ALTERNATIVE_CODE_TYPE_SEDOL1,

        /// SEDOL_2
        TI_ALTERNATIVE_CODE_TYPE_SEDOL2,

        /// SERIES
        TI_ALTERNATIVE_CODE_TYPE_SERIES,

        /// SHORT CODE
        TI_ALTERNATIVE_CODE_TYPE_SHORT_CODE,

        /// SINGAPORE
        TI_ALTERNATIVE_CODE_TYPE_SINGAPORE,

        /// UK EPIC
        TI_ALTERNATIVE_CODE_TYPE_UK_EPIC,

        /// Local_1
        TI_ALTERNATIVE_CODE_TYPE_LOCAL_1,

        /// Local_2
        TI_ALTERNATIVE_CODE_TYPE_LOCAL_2,

        /// Local_3
        TI_ALTERNATIVE_CODE_TYPE_LOCAL_3,

        /// Local_4
        TI_ALTERNATIVE_CODE_TYPE_LOCAL_4,

        /// Local_5
        TI_ALTERNATIVE_CODE_TYPE_LOCAL_5,

        /// Custom_1
        TI_ALTERNATIVE_CODE_TYPE_CUSTOM_1,

        /// Custom_2
        TI_ALTERNATIVE_CODE_TYPE_CUSTOM_2,

        /// Custom_3
        TI_ALTERNATIVE_CODE_TYPE_CUSTOM_3,

        /// Custom_4
        TI_ALTERNATIVE_CODE_TYPE_CUSTOM_4,

        /// Custom_5
        TI_ALTERNATIVE_CODE_TYPE_CUSTOM_5,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_BROKER_TYPE
{
    enum Enum
    {
        /// None
        TI_BROKER_TYPE_None,

        /// Dummy - REPO Market Only
        TI_BROKER_TYPE_Dummy,

        /// Minority Broker - CMF, BV Markets
        TI_BROKER_TYPE_MinorityBroker,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_BUSINESS_DAY_CONV
{
    enum Enum
    {
        /// None
        TI_BUSINESS_DAY_CONV_None,

        /// Following (i.e., the next day that is a business day)
        TI_BUSINESS_DAY_CONV_Following,

        /// Modified Following (i.e., the next day that is a business day; if this day falls in the next calendar month, the most recent previous day that is a business day is taken)
        TI_BUSINESS_DAY_CONV_ModifiedFollowing,

        /// Preceding (i.e., the most recent previous day that is a business day)
        TI_BUSINESS_DAY_CONV_Preceding,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_CALENDAR_EXCEPTION_TYPE
{
    enum Enum
    {
        /// Holiday
        TI_CALENDAR_EXCEPTION_TYPE_Holiday,

        /// Working Day
        TI_CALENDAR_EXCEPTION_TYPE_Working,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_CONNECTION_TYPE
{
    enum Enum
    {
        /// Leased Lines
        TI_CONNECTION_TYPE_LeasedLines,

        /// Internet
        TI_CONNECTION_TYPE_Internet,

        /// Both
        TI_CONNECTION_TYPE_Both,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_COUPON_TYPE
{
    enum Enum
    {
        /// Zero Coupon
        TI_COUPON_TYPE_ZeroCoupon,

        /// Fixed Rate
        TI_COUPON_TYPE_FixedRate,

        /// Floating Rate
        TI_COUPON_TYPE_FloatRate,

        /// Indexed Rate
        TI_COUPON_TYPE_IndexedRate,

        /// Variable Coupon
        TI_COUPON_TYPE_VariableCoupon,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_DAY_COUNT_CONVENTION_TYPE
{
    enum Enum
    {
        /// Zero Coupon (None)
        TI_DAY_COUNT_CONVENTION_TYPE_ZeroCoupon,

        /// ActAct
        TI_DAY_COUNT_CONVENTION_TYPE_ActAct,

        /// Act365
        TI_DAY_COUNT_CONVENTION_TYPE_Act365,

        /// Act360
        TI_DAY_COUNT_CONVENTION_TYPE_Act360,

        /// Act366
        TI_DAY_COUNT_CONVENTION_TYPE_Act366,

        /// 30/360
        TI_DAY_COUNT_CONVENTION_TYPE_30_360,

        /// 30E+1/360
        TI_DAY_COUNT_CONVENTION_TYPE_30E1_360,

        /// 30E/360
        TI_DAY_COUNT_CONVENTION_TYPE_30E_360,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_DESC_ENTITY_TYPE
{
    enum Enum
    {
        /// No Type
        TI_DESC_ENTITY_TYPE_NoType,

        /// Structure
        TI_DESC_ENTITY_TYPE_StructType,

        /// Enumerate
        TI_DESC_ENTITY_TYPE_EnumType,

        /// Union
        TI_DESC_ENTITY_TYPE_UnionType,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_DESC_FIELD_TYPE
{
    enum Enum
    {
        /// None
        TI_DESC_FIELD_TYPE_TypeNONE,

        /// Integer
        TI_DESC_FIELD_TYPE_TypeINT,

        /// Unsigned integer
        TI_DESC_FIELD_TYPE_TypeUINT,

        /// Short integer
        TI_DESC_FIELD_TYPE_TypeSHORT,

        /// Unsigned short integer
        TI_DESC_FIELD_TYPE_TypeUSHORT,

        /// Long integer
        TI_DESC_FIELD_TYPE_TypeLONG,

        /// Unsigned long integer
        TI_DESC_FIELD_TYPE_TypeULONG,

        /// Floating
        TI_DESC_FIELD_TYPE_TypeFLOAT,

        /// Double-precision floating point number
        TI_DESC_FIELD_TYPE_TypeDOUBLE,

        /// Byte
        TI_DESC_FIELD_TYPE_TypeBYTE,

        /// Character
        TI_DESC_FIELD_TYPE_TypeCHAR,

        /// Unsigned character
        TI_DESC_FIELD_TYPE_TypeUCHAR,

        /// String
        TI_DESC_FIELD_TYPE_TypeSTRING,

        /// L time
        TI_DESC_FIELD_TYPE_TypeLTIME,

        /// L date
        TI_DESC_FIELD_TYPE_TypeLDATE,

        /// Boolean
        TI_DESC_FIELD_TYPE_TypeBOOLEAN,

        /// M time
        TI_DESC_FIELD_TYPE_TypeMTIME,

        /// U time
        TI_DESC_FIELD_TYPE_TypeUTIME,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_DESC_KEY_TYPE
{
    enum Enum
    {
        /// Duplicate Key
        TI_DESC_KEY_TYPE_DuplicateKey,

        /// Unique Key
        TI_DESC_KEY_TYPE_UniqueKey,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_DISCOUNT_RATE_FORMULA_TYPE
{
    enum Enum
    {
        /// None
        TI_DISCOUNT_RATE_FORMULA_TYPE_None,

        /// Financial Formula
        TI_DISCOUNT_RATE_FORMULA_TYPE_FinancialFormula,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_ENVIRONMENT
{
    enum Enum
    {
        /// Live Market. Production environment available to all members
        TI_ENVIRONMENT_LiveMarket,

        /// Test. External test environment available to all members
        TI_ENVIRONMENT_Test,

        /// Pre-Production. Pre-production environment available to all members
        TI_ENVIRONMENT_PreProduction,

        /// Internal. Internal test environment reserved to SIA
        TI_ENVIRONMENT_Internal,

        /// Development. Development test environment reserved to SIA.
        TI_ENVIRONMENT_Development,

        /// Simulator. Simulation environment reserved to SIA.
        TI_ENVIRONMENT_Simulator,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_EXCEPTION_DATE_TYPE
{
    enum Enum
    {
        /// None
        TI_EXCEPTION_DATE_TYPE_None,

        /// BlackOut
        TI_EXCEPTION_DATE_TYPE_BlackOut,

        /// ExDividend
        TI_EXCEPTION_DATE_TYPE_ExDividend,

        /// AIT (Poland Accrued Interest Termination Rights)
        TI_EXCEPTION_DATE_TYPE_AIT,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_EXPIRY_TYPE
{
    enum Enum
    {
        /// ExFront
        TI_EXPIRY_TYPE_ExFront,

        /// Front
        TI_EXPIRY_TYPE_Front,

        /// Back
        TI_EXPIRY_TYPE_Back,

        /// NextBack
        TI_EXPIRY_TYPE_NextBack,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_FINANCIAL_INSTRUMENT_TYPE
{
    enum Enum
    {
        /// Bond
        TI_FINANCIAL_INSTRUMENT_TYPE_Bond,

        /// Future Delivery
        TI_FINANCIAL_INSTRUMENT_TYPE_FutureDelivery,

        /// Rate
        TI_FINANCIAL_INSTRUMENT_TYPE_Rate,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_FLAG
{
    enum Enum
    {
        /// No
        TI_FLAG_No,

        /// Yes
        TI_FLAG_Yes,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_FLOW
{
    enum Enum
    {
        /// BPV
        TI_FLOW_BPV,

        /// CleanPrice
        TI_FLOW_CleanPrice,

        /// FuturePrice
        TI_FLOW_FuturePrice,

        /// Yield
        TI_FLOW_Yield,

        /// Benchmark Index Future Value
        TI_FLOW_BenchmarkIndexFutureValue,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_FUNCTION
{
    enum Enum
    {
        /// Firm quote
        TI_FUNCTION_FirmQuote,

        /// FAS orders
        TI_FUNCTION_FASOrders,

        /// FAKAON orders
        TI_FUNCTION_Orders,

        /// RFQ Send
        TI_FUNCTION_RFQSend,

        /// RFQ Respond
        TI_FUNCTION_RFQRespond,

        /// RFCQ Send
        TI_FUNCTION_RFCQSend,

        /// RFCQ Respond
        TI_FUNCTION_RFCQRespond,

        /// Not Used
        TI_FUNCTION_NotUsed,

        /// Inventory quote
        TI_FUNCTION_InventoryQuote,

        /// Stage Orders
        TI_FUNCTION_StageOrders,

        /// Split Fill
        TI_FUNCTION_SplitFill,

        /// Account Definition
        TI_FUNCTION_AccountDefinition,

        /// User Portfolio Definition
        TI_FUNCTION_UserPortfolioDefinition,

        /// Trading Relationship
        TI_FUNCTION_TradingRelationship,

        /// Trading Caps
        TI_FUNCTION_TradingCaps,

        /// Private Info
        TI_FUNCTION_PrivateInfo,

        /// Public Info
        TI_FUNCTION_PublicInfo,

        /// Governance
        TI_FUNCTION_Governance,

        /// FutureBridge
        TI_FUNCTION_FutureBridge,

        /// Trader Configuration
        TI_FUNCTION_TraderConfiguration,

        /// Data feed
        TI_FUNCTION_Data_feed,

        /// Price Contribution
        TI_FUNCTION_PriceContribution,

        /// Financial Calculation
        TI_FUNCTION_FinancialCalculation,

        /// Striker firm quote
        TI_FUNCTION_StrikerFirmQuote,

        /// Striker FAS order
        TI_FUNCTION_StrikerFASOrder,

        /// Mid price FAS order
        TI_FUNCTION_MidPriceFASOrder,

        /// Mid price FOK order
        TI_FUNCTION_MidPriceFOKOrder,

        /// Inventory order send
        TI_FUNCTION_InventoryOrderSend,

        /// Inventory order respond
        TI_FUNCTION_InventoryOrderRespond,

        /// IOI - Indication of Interest
        TI_FUNCTION_IOI,

        /// OTC
        TI_FUNCTION_OTC,

        /// Cash Offer
        TI_FUNCTION_CashOffer,

        /// Collateral Offer
        TI_FUNCTION_CollateralOffer,

        /// EOI - Message
        TI_FUNCTION_EOIMessage,

        /// Counterparty Restriction
        TI_FUNCTION_CounterpartyRestriction,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_FUNCTION_ACTION
{
    enum Enum
    {
        /// None
        TI_FUNCTION_ACTION_None,

        /// Read
        TI_FUNCTION_ACTION_Read,

        /// Read and Write
        TI_FUNCTION_ACTION_ReadWrite,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_FUNCTION_LEVEL
{
    enum Enum
    {
        /// Platform
        TI_FUNCTION_LEVEL_Platform,

        /// Market
        TI_FUNCTION_LEVEL_Market,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_INSTR_CLASS_TYPE
{
    enum Enum
    {
        /// All Classes
        TI_INSTR_CLASS_TYPE_All,

        /// Order
        TI_INSTR_CLASS_TYPE_Order,

        /// Proposal
        TI_INSTR_CLASS_TYPE_Proposal,

        /// Rfq
        TI_INSTR_CLASS_TYPE_Rfq,

        /// Public Info
        TI_INSTR_CLASS_TYPE_PublicInfo,

        /// Private Info
        TI_INSTR_CLASS_TYPE_PrivateInfo,

        /// Inventory Quotes
        TI_INSTR_CLASS_TYPE_InventoryQuotes,

        /// Not Used
        TI_INSTR_CLASS_TYPE_NotUsed,

        /// Not Used
        TI_INSTR_CLASS_TYPE_NotUsed2,

        /// Stage Orders
        TI_INSTR_CLASS_TYPE_StageOrders,

        /// OTC
        TI_INSTR_CLASS_TYPE_OTC,

        /// Mid Price FAS Order
        TI_INSTR_CLASS_TYPE_MidPriceFASOrder,

        /// Mid Price FOK Order
        TI_INSTR_CLASS_TYPE_MidPriceFOKOrder,

        /// Inventory order send
        TI_INSTR_CLASS_TYPE_InventoryOrderSend,

        /// Inventory order respond
        TI_INSTR_CLASS_TYPE_InventoryOrderRespond,

        /// Cash Offer
        TI_INSTR_CLASS_TYPE_CashOffer,

        /// Collateral Offer
        TI_INSTR_CLASS_TYPE_CollateralOffer,

        /// Message Board
        TI_INSTR_CLASS_TYPE_MessageBoard,

        /// IOI
        TI_INSTR_CLASS_TYPE_IOI,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_INSTRUMENT_TYPE
{
    enum Enum
    {
        /// Bond
        TI_INSTRUMENT_TYPE_Bond,

        /// Future
        TI_INSTRUMENT_TYPE_Future,

        /// GC
        TI_INSTRUMENT_TYPE_GC,

        /// Triparty
        TI_INSTRUMENT_TYPE_Triparty,

        /// Basis
        TI_INSTRUMENT_TYPE_Basis,

        /// Spread
        TI_INSTRUMENT_TYPE_Spread,

        /// Spread Free Double
        TI_INSTRUMENT_TYPE_SpreadFreeDouble,

        /// Switch Auction
        TI_INSTRUMENT_TYPE_SwitchAuction,

        /// OIS
        TI_INSTRUMENT_TYPE_OIS,

        /// IRS
        TI_INSTRUMENT_TYPE_IRS,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_INSTRUMENT_TYPOLOGY
{
    enum Enum
    {
        /// Normal Instrument
        TI_INSTRUMENT_TYPOLOGY_Normal,

        /// Strip instrument originating from a coupon stripping program
        TI_INSTRUMENT_TYPOLOGY_Strip,

        /// Corporate Instrument
        TI_INSTRUMENT_TYPOLOGY_Corporate,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_INTRADAY_UPDATE_ENTITY_TYPE
{
    enum Enum
    {
        /// Financial Instrument
        TI_INTRADAY_UPDATE_ENTITY_TYPE_FinancialInstrument,

        /// Tradable Instrument: Bond
        TI_INTRADAY_UPDATE_ENTITY_TYPE_Bond,

        /// Tradable Instrument: Switch Auction
        TI_INTRADAY_UPDATE_ENTITY_TYPE_SwitchAuction,

        /// Issuer
        TI_INTRADAY_UPDATE_ENTITY_TYPE_Issuer,

        /// Member
        TI_INTRADAY_UPDATE_ENTITY_TYPE_Member,

        /// Instrument Class
        TI_INTRADAY_UPDATE_ENTITY_TYPE_InstrumentClass,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_INTRADAY_UPDATE_NOTIFICATION_TYPE
{
    enum Enum
    {
        /// Start
        TI_INTRADAY_UPDATE_NOTIFICATION_TYPE_Start,

        /// End
        TI_INTRADAY_UPDATE_NOTIFICATION_TYPE_End,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_INTRADAY_UPDATE_TYPE
{
    enum Enum
    {
        /// Add
        TI_INTRADAY_UPDATE_TYPE_Add,

        /// Edit
        TI_INTRADAY_UPDATE_TYPE_Edit,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_IRREGULARITY_TYPE
{
    enum Enum
    {
        /// Regular Coupon
        TI_IRREGULARITY_TYPE_RegularCoupon,

        /// First Coupon Long
        TI_IRREGULARITY_TYPE_FirstCouponLong,

        /// First Coupon Short
        TI_IRREGULARITY_TYPE_FirstCouponShort,

        /// Long Coupon
        TI_IRREGULARITY_TYPE_LongCoupon,

        /// Short Coupon
        TI_IRREGULARITY_TYPE_ShortCoupon,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_MARKET_CLASS_TYPE
{
    enum Enum
    {
        /// All Classes
        TI_MARKET_CLASS_TYPE_All,

        /// Member Status
        TI_MARKET_CLASS_TYPE_MemberStatus,

        /// Trader Status
        TI_MARKET_CLASS_TYPE_TraderStatus,

        /// Message
        TI_MARKET_CLASS_TYPE_Message,

        /// 4 - TI_MARKET_CLASS_TYPE_Admin
        ot_used_on_MMF_Platform_REPO_and_SWAP_Markets_and_and_CMF_Platform,

        /// Not used on MMF Platform (REPO and SWAP Markets) and and CMF Platform
        dmin,

        /// Public Info
        TI_MARKET_CLASS_TYPE_PublicInfo,

        /// Private Info
        TI_MARKET_CLASS_TYPE_PrivateInfo,

        /// Governance
        TI_MARKET_CLASS_TYPE_Governance,

        /// Issuer
        TI_MARKET_CLASS_TYPE_Issuer,

        /// Trader Group Status
        TI_MARKET_CLASS_TYPE_GroupStatus,

        /// Trading Relation
        TI_MARKET_CLASS_TYPE_TradingRelation,

        /// Trading Caps
        TI_MARKET_CLASS_TYPE_TradingCaps,

        /// Instrument Class Enable
        TI_MARKET_CLASS_TYPE_InstrumentClassEnable,

        /// RFCQ
        TI_MARKET_CLASS_TYPE_Rfcq,

        /// Financial Calculator
        TI_MARKET_CLASS_TYPE_FinancialCalculator,

        /// Sales Configuration
        TI_MARKET_CLASS_TYPE_SalesConfig,

        /// Trade Splitting
        TI_MARKET_CLASS_TYPE_TradeSplitting,

        /// Trading Idea
        TI_MARKET_CLASS_TYPE_TradingIdea,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_MEMBER_CLASSIFICATION
{
    enum Enum
    {
        /// No Classification
        TI_MEMBER_CLASSIFICATION_None,

        /// Asset Manager
        TI_MEMBER_CLASSIFICATION_AssetManager,

        /// Bank
        TI_MEMBER_CLASSIFICATION_Bank,

        /// Bank Treasury
        TI_MEMBER_CLASSIFICATION_BankTreasury,

        /// Broker
        TI_MEMBER_CLASSIFICATION_Broker,

        /// Central Bank
        TI_MEMBER_CLASSIFICATION_CentralBank,

        /// Corporate Treasury
        TI_MEMBER_CLASSIFICATION_CorporateTreasury,

        /// Government Organization
        TI_MEMBER_CLASSIFICATION_GovernmentOrganization,

        /// Hedge Fund
        TI_MEMBER_CLASSIFICATION_HedgeFund,

        /// Insurance
        TI_MEMBER_CLASSIFICATION_Insurance,

        /// Pension Fund
        TI_MEMBER_CLASSIFICATION_PensionFund,

        /// Primary Dealer
        TI_MEMBER_CLASSIFICATION_PrimaryDealer,

        /// Private Bank
        TI_MEMBER_CLASSIFICATION_PrivateBank,

        /// Agency and Supras
        TI_MEMBER_CLASSIFICATION_AgenciesAndSupras,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_MEMBER_PROFILE
{
    enum Enum
    {
        /// None
        TI_MEMBER_PROFILE_None,

        /// Primary
        TI_MEMBER_PROFILE_Primary,

        /// Dealer
        TI_MEMBER_PROFILE_Dealer,

        /// MTS SpA
        TI_MEMBER_PROFILE_MTS_SpA,

        /// Primary with No RFQ - REPO Market Only
        TI_MEMBER_PROFILE_PrimaryNoRFQ,

        /// SIA
        TI_MEMBER_PROFILE_SIA,

        /// Datafeed
        TI_MEMBER_PROFILE_Datafeed,

        /// Press Agency
        TI_MEMBER_PROFILE_Press,

        /// Observer
        TI_MEMBER_PROFILE_Observer,

        /// Agent
        TI_MEMBER_PROFILE_Agent,

        /// Custodian
        TI_MEMBER_PROFILE_Custodian,

        /// Dealer No FAS - Not Used
        TI_MEMBER_PROFILE_DealerNoFAS,

        /// Third Party Access
        TI_MEMBER_PROFILE_ThirdParty,

        /// Data Subscriber - CMF, BV Markets only
        TI_MEMBER_PROFILE_DataSubscriber,

        /// Primary Issuer
        TI_MEMBER_PROFILE_PrimaryIssuer,

        /// Futures Bridge
        TI_MEMBER_PROFILE_FuturesBridge,

        /// Clearing House
        TI_MEMBER_PROFILE_ClearingHouse,

        /// Price Feed
        TI_MEMBER_PROFILE_PriceFeed,

        /// All
        TI_MEMBER_PROFILE_All,

        /// Dealer Only Ask
        TI_MEMBER_PROFILE_DealerOnlyAsk,

        /// Dealer Only Bid
        TI_MEMBER_PROFILE_DealerOnlyBid,

        /// ThirdParty Access Sponsor RFQ
        TI_MEMBER_PROFILE_ThirdPartyAccessSponsorRFQ,

        /// MTS Trader Config
        TI_MEMBER_PROFILE_MTSTraderConfig,

        /// Third Party Access Client
        TI_MEMBER_PROFILE_ThirdPartyAccessClient,

        /// Third Party Access Sponsor
        TI_MEMBER_PROFILE_ThirdPartyAccessSponsor,

        /// Dealer FAS Only Ask
        TI_MEMBER_PROFILE_DealerFASOnlyAsk,

        /// Dealer FAS Only Bid
        TI_MEMBER_PROFILE_DealerFASOnlyBid,

        /// Dealer with No RFQ - REPO Market Only
        TI_MEMBER_PROFILE_DealerNoRFQ,

        /// Primary without OTC - REPO Market Only
        TI_MEMBER_PROFILE_PrimaryNoOTC,

        /// Primary without OTC and RFQ - REPO Market Only
        TI_MEMBER_PROFILE_PrimaryNoOTCAndRFQ,

        /// Broker - REPO Market Only
        TI_MEMBER_PROFILE_Broker,

        /// Broker Plus - REPO Market Only
        TI_MEMBER_PROFILE_BrokerPlus,

        /// Cash Provider - REPO Market Only
        TI_MEMBER_PROFILE_CashProvider,

        /// Collateral Provider - REPO Market Only
        TI_MEMBER_PROFILE_CollateralProvider,

        /// Cash and Collateral Provider - REPO Market Only
        TI_MEMBER_PROFILE_CashAndCollateralProvider,

        /// ACM - REPO Market Only
        TI_MEMBER_PROFILE_ACM,

        /// Security Lender and Agency Broker
        TI_MEMBER_PROFILE_SecLenderAgencyBroker,

        /// B2C Client - REPO Market Only
        TI_MEMBER_PROFILE_Client,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_MEMBER_TYPE
{
    enum Enum
    {
        /// Normal trader
        TI_MEMBER_TYPE_NormalTrader,

        /// Clearing House
        TI_MEMBER_TYPE_ClearingHouse,

        /// Agent
        TI_MEMBER_TYPE_Agent,

        /// Treasury
        TI_MEMBER_TYPE_Treasury,

        /// PriceFeed
        TI_MEMBER_TYPE_PriceFeed,

        /// Data Feed
        TI_MEMBER_TYPE_DataFeed,

        /// Governance
        TI_MEMBER_TYPE_Governance,

        /// Observer
        TI_MEMBER_TYPE_Observer,

        /// Futures Bridge
        TI_MEMBER_TYPE_FuturesBridge,

        /// MTS Trader Config
        TI_MEMBER_TYPE_MTSTraderConfig,

        /// Multimember
        TI_MEMBER_TYPE_Multimember,

        /// Broker
        TI_MEMBER_TYPE_Broker,

        /// MTS Broker Plus
        TI_MEMBER_TYPE_BrokerPlus,

        /// Data Subscriber
        TI_MEMBER_TYPE_DataSubscriber,

        /// Security Lender and Agency Broker
        TI_MEMBER_TYPE_SecLenderAgencyBroker,

        /// Client
        TI_MEMBER_TYPE_Client,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_MKT_LINK_TYPE
{
    enum Enum
    {
        /// NoTrading
        TI_MKT_LINK_TYPE_NoTrading,

        /// Multimember
        TI_MKT_LINK_TYPE_Multimember,

        /// OTC Broker
        TI_MKT_LINK_TYPE_OTC_Broker,

        /// Sponsor
        TI_MKT_LINK_TYPE_Sponsor,

        /// Preferred Dealer
        TI_MKT_LINK_TYPE_PreferredDealer,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_NETWORK_TYPE
{
    enum Enum
    {
        /// Undefined
        TI_NETWORK_TYPE_Undefined,

        /// SIA
        TI_NETWORK_TYPE_SIA,

        /// Internet
        TI_NETWORK_TYPE_Internet,

        /// Radianz
        TI_NETWORK_TYPE_Radianz,

        /// Bit Systems
        TI_NETWORK_TYPE_BitSystems,

        /// Proximity
        TI_NETWORK_TYPE_Proximity,

        /// UPC
        TI_NETWORK_TYPE_UPC,

        /// Virtual GUI
        TI_NETWORK_TYPE_VGUI,

        /// Fixnetix
        TI_NETWORK_TYPE_Fixnetix,

        /// Unused1
        TI_NETWORK_TYPE_Unused1,

        /// Unused2
        TI_NETWORK_TYPE_Unused2,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_PERIOD
{
    enum Enum
    {
        /// Day
        TI_PERIOD_Day,

        /// Week
        TI_PERIOD_Week,

        /// Month
        TI_PERIOD_Month,

        /// Year
        TI_PERIOD_Year,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_PHASE
{
    enum Enum
    {
        /// System Down
        TI_PHASE_SystemDown,

        /// Close Market
        TI_PHASE_CloseMarket,

        /// Pre-Market
        TI_PHASE_PreMarket,

        /// Offer Market (only for CMF market)
        TI_PHASE_OfferMarket,

        /// Open Market
        TI_PHASE_OpenMarket,

        /// Evaluation (only for Auction market)
        TI_PHASE_Evaluation,

        /// Finalisation (only for Auction market)
        TI_PHASE_Finalisation,

        /// Split Definition (only for CMF market)
        TI_PHASE_SplitDefinition,

        /// After Hours (only for CMF market)
        TI_PHASE_AfterHours,

        /// Cash Entry (only for REPO/ACM market)
        TI_PHASE_CashEntry,

        /// Collateral Entry (only for REPO/ACM market)
        TI_PHASE_CollateralEntry,

        /// Execution (only for REPO/ACM market)
        TI_PHASE_Execution,

        /// Closed (only for REPO/ACM market)
        TI_PHASE_Closing,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_PLATFORM_CLASS_TYPE
{
    enum Enum
    {
        /// All Classes
        TI_PLATFORM_CLASS_TYPE_All,

        /// Message
        TI_PLATFORM_CLASS_TYPE_Message,

        /// Admin
        TI_PLATFORM_CLASS_TYPE_Admin,

        /// Member Account
        TI_PLATFORM_CLASS_TYPE_MemberAccount,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_PROTOCOL_SOURCE
{
    enum Enum
    {
        /// SDP
        TI_PROTOCOL_SOURCE_Sdp,

        /// FIX
        TI_PROTOCOL_SOURCE_Fix,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_QUERY_OP
{
    enum Enum
    {
        /// None. The query parameter is not included in the query search condition.
        TI_QUERY_OP_None,

        /// The query parameter is included in the query search condition using the Less Than operator.
        TI_QUERY_OP_LT,

        /// The query parameter is included in the query search condition using the Less Than Equal operator.
        TI_QUERY_OP_LTE,

        /// The query parameter is included in the query search condition using the Greater Than operator.
        TI_QUERY_OP_GT,

        /// The query parameter is included in the query search condition using the Greater Than Equal operator.
        TI_QUERY_OP_GTE,

        /// The query parameter is included in the query search condition using the Equal operator.
        TI_QUERY_OP_EQ,

        /// Like. The query parameter is included in the query search condition using the Like operator. Valid for STRING parameters only.
        TI_QUERY_OP_LIKE,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_SECURITY_TYPE
{
    enum Enum
    {
        /// Plain TCP
        TI_SECURITY_TYPE_PlainTCP,

        /// SSL (No certificate)
        TI_SECURITY_TYPE_SSL,

        /// SSL Certificate
        TI_SECURITY_TYPE_SSLCertificate,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_SETTL_TYPE
{
    enum Enum
    {
        /// Manual
        TI_SETTL_TYPE_Manual,

        /// PSTA
        TI_SETTL_TYPE_PSTA,

        /// RRG
        TI_SETTL_TYPE_RRG,

        /// Only Report
        TI_SETTL_TYPE_OnlyReport,

        /// Swapswire Automatic (implies pre confirmation)
        TI_SETTL_TYPE_Swapswire_Auto,

        /// Swapswire Manual (implies voice confirmation)
        TI_SETTL_TYPE_Swapswire_Manual,

        /// X-COM
        TI_SETTL_TYPE_XCOM,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_SETTLEMENT_MODE
{
    enum Enum
    {
        /// None
        TI_SETTLEMENT_MODE_None,

        /// CCP Only
        TI_SETTLEMENT_MODE_CCPOnly,

        /// Bilateral Only
        TI_SETTLEMENT_MODE_BilateralOnly,

        /// Both
        TI_SETTLEMENT_MODE_Both,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_SUSP_STATUS
{
    enum Enum
    {
        /// Active
        TI_SUSP_STATUS_Active,

        /// Suspended
        TI_SUSP_STATUS_Suspended,

        /// Suspended Today. Reserved for future use.
        TI_SUSP_STATUS_SuspendedToday,

        /// Waiting For Contribution
        TI_SUSP_STATUS_WaitingForContribution,

        /// Intraday Update. Reserved for CMF, BV Markets.
        TI_SUSP_STATUS_IntradayUpdate,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_TRADER_ACCOUNT_STATUS
{
    enum Enum
    {
        /// Inactive
        TI_TRADER_ACCOUNT_STATUS_Inactive,

        /// Active
        TI_TRADER_ACCOUNT_STATUS_Active,

        /// To be deleted
        TI_TRADER_ACCOUNT_STATUS_ToBeDeleted,

        /// Deleted
        TI_TRADER_ACCOUNT_STATUS_Deleted,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_TRADER_TYPE
{
    enum Enum
    {
        /// Manager
        TI_TRADER_TYPE_Manager,

        /// Trader
        TI_TRADER_TYPE_Trader,

        /// Auto Trader
        TI_TRADER_TYPE_AutoTrader,

        /// Sales (CMF, BV Markets)
        TI_TRADER_TYPE_Sales,

        /// PMS (CMF, BV Markets)
        TI_TRADER_TYPE_PMS,

        /// E-Commerce (For future use)
        TI_TRADER_TYPE_Ecommerce,

        /// Back Office (For future use)
        TI_TRADER_TYPE_Backoffice,

        /// Super User (For future use)
        TI_TRADER_TYPE_SuperUser,

        /// Viewer (For future use)
        TI_TRADER_TYPE_Viewer,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_TRADING_FUNCTION
{
    enum Enum
    {
        /// Firm quote
        TI_TRADING_FUNCTION_FirmQuote,

        /// FAS orders
        TI_TRADING_FUNCTION_FASOrders,

        /// FAK/AON orders
        TI_TRADING_FUNCTION_Orders,

        /// RFQ
        TI_TRADING_FUNCTION_RFQ,

        /// RFCQ
        TI_TRADING_FUNCTION_RFCQ,

        /// Not Used
        TI_TRADING_FUNCTION_NotUsed,

        /// Inventory quote
        TI_TRADING_FUNCTION_InventoryQuote,

        /// Stage Orders
        TI_TRADING_FUNCTION_StageOrder,

        /// Split Fill
        TI_TRADING_FUNCTION_SplitFill,

        /// Striker Firm Quote
        TI_TRADING_FUNCTION_StrikerFirmQuote,

        /// Striker FAS Order
        TI_TRADING_FUNCTION_StrikerFASOrder,

        /// Mid price FAS Order
        TI_TRADING_FUNCTION_MidPriceFASOrder,

        /// Mid price FOK Order
        TI_TRADING_FUNCTION_MidPriceFOKOrder,

        /// Inventory Order
        TI_TRADING_FUNCTION_InventoryOrder,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_TRADING_MODALITY
{
    enum Enum
    {
        /// CAT
        TI_TRADING_MODALIY_Cat,

        /// RFCQ
        TI_TRADING_MODALIY_Rfcq,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_TRADING_TYPE
{
    enum Enum
    {
        /// Clean Price (Decimal Price). In CMF market trading classes, the Clean Price value is contained in the Price field.
        TI_TRADING_TYPE_CleanPrice,

        /// Yield. In CMF market trading classes, the Yield value is contained in the Yield field.
        TI_TRADING_TYPE_Yield,

        /// Dirty Price. In CMF market trading classes, the Dirty Price value is contained in the Price field.
        TI_TRADING_TYPE_DirtyPrice,

        /// Price32. In CMF market trading classes, the 32nd Price value is contained in the Price field.
        TI_TRADING_TYPE_Price32,

        /// Yield Diff. In CMF market trading classes, the Yield Diff (spread value) is contained in the Yield field.
        TI_TRADING_TYPE_YieldDiff,

        /// Price Diff. In CMF market trading classes, the Price Diff (spread value) is contained in the Price field.
        TI_TRADING_TYPE_PriceDiff,

        /// Rate.
        TI_TRADING_TYPE_Rate,

        /// Rate Spread (For future use)
        TI_TRADING_TYPE_RateSpread,

        /// Basis Point. In CMF market trading classes, the Basis value is contained in the Price field.
        TI_TRADING_TYPE_BasisPoint,

        /// Break Even Spread. In CMF market trading classes, the Break Even Spread value is contained in the Yield field.
        TI_TRADING_TYPE_BreakEvenSpread,

        /// Discount Rate. In CMF market trading classes, the Discount Rate value is contained in the Price field.
        TI_TRADING_TYPE_DiscountRate,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_UTC
{
    enum Enum
    {
        /// None
        TI_UTC_None,

        /// UTC-12:00
        TI_UTC_Minus_1200,

        /// UTC-11:00
        TI_UTC_Minus_1100,

        /// UTC-10:00
        TI_UTC_Minus_1000,

        /// UTC-09:30
        TI_UTC_Minus_0930,

        /// UTC-09:00
        TI_UTC_Minus_0900,

        /// UTC-08:00
        TI_UTC_Minus_0800,

        /// UTC-07:00
        TI_UTC_Minus_0700,

        /// UTC-06:00
        TI_UTC_Minus_0600,

        /// UTC-05:00
        TI_UTC_Minus_0500,

        /// UTC-04:30
        TI_UTC_Minus_0430,

        /// UTC-04:00
        TI_UTC_Minus_0400,

        /// UTC-03:30
        TI_UTC_Minus_0330,

        /// UTC-03:00
        TI_UTC_Minus_0300,

        /// UTC-02:00
        TI_UTC_Minus_0200,

        /// UTC-01:00
        TI_UTC_Minus_0100,

        /// UTC 00:00
        TI_UTC_0000,

        /// UTC+01:00
        TI_UTC_Plus_0100,

        /// UTC+02:00
        TI_UTC_Plus_0200,

        /// UTC+03:00
        TI_UTC_Plus_0300,

        /// UTC+03:30
        TI_UTC_Plus_0330,

        /// UTC+04:00
        TI_UTC_Plus_0400,

        /// UTC+04:30
        TI_UTC_Plus_0430,

        /// UTC+05:00
        TI_UTC_Plus_0500,

        /// UTC+05:30
        TI_UTC_Plus_0530,

        /// UTC+05:45
        TI_UTC_Plus_0545,

        /// UTC+06:00
        TI_UTC_Plus_0600,

        /// UTC+06:30
        TI_UTC_Plus_0630,

        /// UTC+07:00
        TI_UTC_Plus_0700,

        /// UTC+08:00
        TI_UTC_Plus_0800,

        /// UTC+08:45
        TI_UTC_Plus_0845,

        /// UTC+09:00
        TI_UTC_Plus_0900,

        /// UTC+09:30
        TI_UTC_Plus_0930,

        /// UTC+10:00
        TI_UTC_Plus_1000,

        /// UTC+10:30
        TI_UTC_Plus_1030,

        /// UTC+11:00
        TI_UTC_Plus_1100,

        /// UTC+11:30
        TI_UTC_Plus_1130,

        /// UTC+12:00
        TI_UTC_Plus_1200,

        /// UTC+12:45
        TI_UTC_Plus_1245,

        /// UTC+13:00
        TI_UTC_Plus_1300,

        /// UTC+14:00
        TI_UTC_Plus_1400,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_WEEK_DAY
{
    enum Enum
    {
        /// Undefined
        TI_WEEK_DAY_Undefined,

        /// Monday
        TI_WEEK_DAY_Monday,

        /// Tuesday
        TI_WEEK_DAY_Tuesday,

        /// Wednesday
        TI_WEEK_DAY_Wednesday,

        /// Thursday
        TI_WEEK_DAY_Thursday,

        /// Friday
        TI_WEEK_DAY_Friday,

        /// Saturday
        TI_WEEK_DAY_Saturday,

        /// Sunday
        TI_WEEK_DAY_Sunday,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_YIELD_FORMULA_TYPE
{
    enum Enum
    {
        /// None. Formula not available
        TI_YIELD_FORMULA_TYPE_None,

        /// ZC Simple. Simple interest formula for Zero Coupons, Act/360, Act/365 or Act/366 convention
        TI_YIELD_FORMULA_TYPE_ZCSimple,

        /// ZC Compound. Compound interest formula for Zero Coupons, Act/360, Act/365 or Act/366 convention
        TI_YIELD_FORMULA_TYPE_ZCCompound,

        /// Fixed Rate. Interest formula for Spread Coupons
        TI_YIELD_FORMULA_TYPE_FixedRate,

        /// One Year To Maturity. Price/Yield conversion formula for annual coupon bearing bonds of less than one year to maturity
        TI_YIELD_FORMULA_TYPE_OneYearToMaturity,

        /// Financial Formulae
        TI_YIELD_FORMULA_TYPE_FinFormulae,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};


struct ONIXS_MTS_REPO_SDP_API TI_ERROR
{
    enum Enum
    {
        /// All right
        TI_ERROR_NoError,

        /// Internal error
        TI_ERROR_InternalError,

        /// Message not managed
        TI_ERROR_MsgNotManaged,

        /// Internal Database error
        TI_ERROR_InternalDatabaseError,

        /// I/O error on file
        TI_ERROR_FileError,

        /// Invalid event
        TI_ERROR_InvalidEvent,

        /// Invalid field value
        TI_ERROR_InvalidFieldValue,

        /// Invalid request
        TI_ERROR_InvalidRequest,

        /// User logon not found
        TI_ERROR_LogonUserNotFound,

        /// Invalid logon state
        TI_ERROR_InvalidLogonState,

        /// Password expired
        TI_ERROR_PasswordExpired,

        /// Wrong password
        TI_ERROR_WrongPassword,

        /// Invalid new password
        TI_ERROR_InvalidNewPassword,

        /// Account Expired
        TI_ERROR_AccountExpired,

        /// Member status not found
        TI_ERROR_MemberStatusNotFound,

        /// Invalid member status
        TI_ERROR_InvalidMemberStatus,

        /// Sender not owner of transaction
        TI_ERROR_NotOwnerOfTransaction,

        /// Maximum number of connections exceeded
        TI_ERROR_MaxConnectionsExceeded,

        /// Product not found
        TI_ERROR_ProductNotFound,

        /// Member not found
        TI_ERROR_MemberNotFound,

        /// Trader not found
        TI_ERROR_TraderNotFound,

        /// Member profile not found
        TI_ERROR_MemberProfileNotFound,

        /// Action not allowed in this market phase
        TI_ERROR_InvalidPhase,

        /// Invalid Proposal
        TI_ERROR_InvalidProposal,

        /// Invalid order
        TI_ERROR_InvalidOrder,

        /// Invalid RFQ
        TI_ERROR_InvalidRFQ,

        /// Invalid quantity
        TI_ERROR_InvalidQty,

        /// Invalid rate
        TI_ERROR_InvalidRate,

        /// Invalid date
        TI_ERROR_InvalidDate,

        /// Invalid verb
        TI_ERROR_InvalidVerb,

        /// Invalid status
        TI_ERROR_InvalidStatus,

        /// Invalid spot price
        TI_ERROR_InvalidSpotPrice,

        /// Order expired
        TI_ERROR_OrderExpired,

        /// Proposal not found
        TI_ERROR_ProposalNotFound,

        /// Order not found
        TI_ERROR_OrderNotFound,

        /// Quantity in trading
        TI_ERROR_QtyInTrading,

        /// Mismatch rate in order
        TI_ERROR_OrdMismatchRate,

        /// Order quantity less than minimum size
        TI_ERROR_MinimumSizeQty,

        /// Maximum number of proposal exceeded
        TI_ERROR_MaximumProposalExceeded,

        /// Suspension failed
        TI_ERROR_SuspensionFailure,

        /// Proposal not active
        TI_ERROR_ProposalNotActive,

        /// Product not active
        TI_ERROR_ProductNotActive,

        /// Member not active
        TI_ERROR_MemberNotActive,

        /// Operator not active
        TI_ERROR_OperatorNotActive,

        /// Bad parameters
        TI_ERROR_BadParameters,

        /// Wrong query Id
        TI_ERROR_WrongQueryId,

        /// Generic error
        TI_ERROR_GenericError,

        /// Query closed by Client
        TI_ERROR_QueryClosedbyClient,

        /// Query terminated by a system error
        TI_ERROR_Queryterminatedbyasystemerror,

        /// Query terminated by Alive Timeout
        TI_ERROR_QueryterminatedbyAliveTimeout,

        /// Wrong query key
        TI_ERROR_WrongQueryKey,

        /// Wrong row number
        TI_ERROR_WrongRowNumber,

        /// Wrong Market ID
        TI_ERROR_WrongMarketID,

        /// No right to make this transaction
        TI_ERROR_NoRights,

        /// Section Field empty
        TI_ERROR_NoSectionField,

        /// Instrument Field empty
        TI_ERROR_NoInstrumentField,

        /// No pair exists with this section and instrument
        TI_ERROR_NoPairFound,

        /// Market suspended
        TI_ERROR_MarketSuspended,

        /// Member suspended on this market
        TI_ERROR_MemberMktSuspended,

        /// Member suspended on this section
        TI_ERROR_MemberMktSectSuspended,

        /// Instrument suspended on this market
        TI_ERROR_InstMarketSuspended,

        /// Member suspended on this instrument class
        TI_ERROR_InstClMemMarketSuspended,

        /// Member suspended on this instrument class and section
        TI_ERROR_InstClMemMarketSectSuspended,

        /// Invalid data
        TI_ERROR_InvalidData,

        /// No instrument for this section
        TI_ERROR_NoInstForSection,

        /// Action not allowed
        TI_ERROR_ActionNotAllowed,

        /// Transaction not allowed in this phase
        TI_ERROR_NoTransPhase,

        /// Wrong Proposal Image
        TI_ERROR_WrongProposalImage,

        /// Proposal not allowed for expired cut off
        TI_ERROR_CutOffProposalNotAllowed,

        /// Repo Type or Settlement Group incompatible
        TI_ERROR_RepoConfigMismatch,

        /// Trade Error - Proposal is CCP Only
        TI_ERROR_CCPOnlyProposal,

        /// Exceeded credit limit or No credit line present
        TI_ERROR_CreditExceeded,

        /// Invalid event for current order status
        TI_ERROR_InvalidOrderState,

        /// Wrong order Id
        TI_ERROR_WrongOrderId,

        /// Invalid Size
        TI_ERROR_InvalidSize,

        /// Wrong Member Id
        TI_ERROR_WrongMember,

        /// Order sent to Invalid Proposal
        TI_ERROR_OrderWithInvalidProposal,

        /// Instrument mismatch
        TI_ERROR_InstrumentMismatch,

        /// Rate Error - Order Rate differs from Proposal
        TI_ERROR_OrderRateMismatch,

        /// Size Error - Order Size is below the Proposal Minimum Quantity
        TI_ERROR_InsufficientOrderQuantity,

        /// Queued order under acceptance
        TI_ERROR_OrderUnderAccept,

        /// Invalid Order Quantity
        TI_ERROR_OrderInvalidQuantity,

        /// Quantity not available
        TI_ERROR_QuantityNotAvailable,

        /// Provider member is Trade Off
        TI_ERROR_ProviderTradeOff,

        /// Cannot trade against self
        TI_ERROR_SelfTrade,

        /// Wrong Trader Id
        TI_ERROR_WrongTrader,

        /// Wrong Proposal Id
        TI_ERROR_WrongProposalId,

        /// Country suspended by Governance
        TI_ERROR_CountrySuspended,

        /// Settlement Error - Member is unable to trade this Bond Type
        TI_ERROR_InvalidSettlementGroup,

        /// Maximum number of proposals on single instrument exceeded
        TI_ERROR_TooManyProposal,

        /// Bilateral Proposals for this Bond Type must be name Give Up
        TI_ERROR_MustBeGiveUp,

        /// Proposal Error - Cut Off has passed
        TI_ERROR_CutOffExpired,

        /// Proposal Error - Member is not a member of the CCP
        TI_ERROR_NonCCPMember,

        /// Proposal Error - Proposal is locked
        TI_ERROR_LockedProposal,

        /// Proposal Error - CCP is not available for these dates
        TI_ERROR_CCPNotAvailable,

        /// Proposal Error - Rate cannot exceed 100
        TI_ERROR_RateTooBig,

        /// Wrong floating rate Id
        TI_ERROR_InvalidFloatingRate,

        /// Proposal Error - Member is not a member of a CCP
        TI_ERROR_PropNoCCPMember,

        /// Proposal Error - Please enter a Size
        TI_ERROR_PropSizeMissing,

        /// Proposal Error - Invalid Size
        TI_ERROR_PropInvalidSize,

        /// Proposal Error - Invalid Total Size
        TI_ERROR_PropInvalidTotSize,

        /// Proposal Error - Invalid Minimum Quantity
        TI_ERROR_PropInvalidMinQty,

        /// Proposal Error - Invalid Rate
        TI_ERROR_PropInvalidRate,

        /// Proposal Error - Invalid Size Combination
        TI_ERROR_PropInvalidSizeComb,

        /// Proposal Error - Invalid Minimum Proposal Quantity
        TI_ERROR_PropInvalidMinDrip,

        /// Proposal Error - End Date chosen precedes Start Date
        TI_ERROR_PropEndDateEarlier,

        /// Proposal Error - Invalid Size below Minimum Proposal Quantity
        TI_ERROR_PropQtyBelowMinDrip,

        /// Wrong Edit time
        TI_ERROR_PropWrongEditTime,

        /// Invalid event for current proposal status
        TI_ERROR_PropInvalidEvent,

        /// Proposal Error - Date is suspended
        TI_ERROR_PropDateSuspended,

        /// RFQ Error - Invalid Rate
        TI_ERROR_RFQInvalidRate,

        /// RFQ cannot be pre-Accepted
        TI_ERROR_RFQPreAccepted,

        /// RFQ not Active
        TI_ERROR_RFQInactive,

        /// RFQ Error - End Date chosen precedes Start Date
        TI_ERROR_RFQEndDateEarlier,

        /// RFQ Error - Invalid Dates
        TI_ERROR_RFQInvalidDates,

        /// Invalid Aggressor Member Id
        TI_ERROR_WrongAggressorMember,

        /// RFQ Error - Invalid Size
        TI_ERROR_RFQInvalidQty,

        /// RFQ FloatRateId is invalid
        TI_ERROR_RFQInvalidFloatRate,

        /// RFQ Error - Recipient not enabled for Bond Type
        TI_ERROR_RFQRecipientNotEnabled,

        /// RFQ Error - Recipient is not Logged On
        TI_ERROR_RFQRecipientNotLogged,

        /// Wrong RFQ Id
        TI_ERROR_WrongRFQ,

        /// RFQ to be managed by counterparty
        TI_ERROR_RFQInvalidSide,

        /// RFQ Error - Unable to change Rate
        TI_ERROR_RFQWrongRateChange,

        /// RFQ Error - Unable to change Quantity
        TI_ERROR_RFQWrongQtyChange,

        /// Wrong General Collateral Id
        TI_ERROR_WrongGCId,

        /// Action not allowed: GC locked or already defined
        TI_ERROR_GCLocked,

        /// Action not allowed: to be defined by the seller
        TI_ERROR_GCSellerAction,

        /// Allocation Error - See Allocation Rules
        TI_ERROR_GCAllocRules,

        /// Allocation Error - Invalid Allocation Quantity
        TI_ERROR_GCInvalidAllocQty,

        /// Allocation error - Wrong quantity allocated
        TI_ERROR_GCWrongAlloc,

        /// Allocation Error - Invalid Collateral Selected
        TI_ERROR_GCWrongSelection,

        /// Allocation Error - Member disabled to specific Instrument Class
        TI_ERROR_GCMemberDisabled,

        /// Allocation Error - Wrong date for allocation
        TI_ERROR_GCWrongDate,

        /// Action not allowed for invalid plain vanilla Id
        TI_ERROR_WrongPlainVanilla,

        /// Invalid Start Date
        TI_ERROR_InvalidStartDate,

        /// Invalid End Date
        TI_ERROR_InvalidEndDate,

        /// Action not allowed: start date cannot be before than trade date
        TI_ERROR_EarlierStartDate,

        /// Incompatible Dates: start date must fall before end date
        TI_ERROR_IncompatibleDates,

        /// Start or End date falls on a Holiday
        TI_ERROR_DateIsHoliday,

        /// Invalid Dates - Term exceeds maximum allowed
        TI_ERROR_DateTooFar,

        /// Action not allowed: wrong calendar Id
        TI_ERROR_WrongCalendarId,

        /// Invalid Clean Price
        TI_ERROR_InvalidCP,

        /// Bond not found
        TI_ERROR_WrongBond,

        /// Invalid Start Date - Check Bond Settlement Date
        TI_ERROR_SettlStartDate,

        /// Invalid End Date - Check Bond Maturity
        TI_ERROR_BondMaturityDate,

        /// Action inconsistent with current fill status
        TI_ERROR_InvalidFillAction,

        /// Action not allowed for wrong fill Id
        TI_ERROR_WrongFillId,

        /// Logon Error - Invalid Username
        TI_ERROR_LogonInvalidUser,

        /// Logon Error - Invalid Member ID
        TI_ERROR_LogonInvalidMember,

        /// Logon Error - Trader Limit Exceeded
        TI_ERROR_TooManyTraders,

        /// Logon Error - User is suspended
        TI_ERROR_LogonUserSuspended,

        /// Logon Error - Trader Account Expired
        TI_ERROR_LogonAccountExpired,

        /// Logon Error - Incorrect Password
        TI_ERROR_LogonWrongPassword,

        /// Logon Error - Password has expired
        TI_ERROR_LogonPasswordExpired,

        /// Recipient not allowed to receive this message
        TI_ERROR_InvalidRecipient,

        /// Cannot send Chat - RFQ has expired
        TI_ERROR_ChatRFQExpired,

        /// This transaction pertains to another trader
        TI_ERROR_WrongOwnership,

        /// Administration Error - User does not have Manager profile
        TI_ERROR_ManagerOnlyAction,

        /// Action not allowed for wrong trader Id
        TI_ERROR_PwdWrongTrader,

        /// Action not allowed for wrong member Id
        TI_ERROR_PwdWrongMember,

        /// Admin Error - Flag already present
        TI_ERROR_CLAlreadyPresent,

        /// Admin Error - ECL Reactivation limit reached
        TI_ERROR_ECLReactLimit,

        /// Admin Error - Record not present
        TI_ERROR_InvalidRecord,

        /// Admin Error - Cannot flag Self
        TI_ERROR_CLSelf,

        /// Member not allowed to send this transaction for wrong market Id
        TI_ERROR_AdmInvalidMarket,

        /// Member not allowed to send this transaction for wrong country Id
        TI_ERROR_AdmInvalidCountry,

        /// Member not allowed to send this tx for wrong receiver details
        TI_ERROR_AdmWrongReceiver,

        /// Member not allowed to send this transaction for wrong trader Id
        TI_ERROR_AdmWrongTrader,

        /// Tradeon Error - Market is Closed
        TI_ERROR_NoSessionOpen,

        /// Tradeon Error - Member Tradeon Prohibited
        TI_ERROR_NoChangeStatus,

        /// Tradeon Error - Trader already Tradeon
        TI_ERROR_AlreadyTradeOn,

        /// Tradeon Error - Invalid Member Status
        TI_ERROR_TrInvalidMemberStatus,

        /// Reached max number of configurable trader with Var. Window Size
        TI_ERROR_AdmMaxVarTraders,

        /// Reached max number of configurable trader with Fixed Window Size
        TI_ERROR_AdmMaxFixedTraders,

        /// Invalid End Date - Start and End date cannot be the same
        TI_ERROR_AdmSameDate,

        /// Admin Error - Manager cannot modify own Profile
        TI_ERROR_AdmSelfUpdate,

        /// Action not compliant with the type of operator profile
        TI_ERROR_ManagerTransaction,

        /// Invalid Member Choice
        TI_ERROR_AdmInvalidMember,

        /// Invalid Password - Expiry
        TI_ERROR_PwdInvalidExpiry,

        /// Invalid Password - Minimum 8 Characters
        TI_ERROR_PwdTooShort,

        /// Invalid Password - Must be Alphanumeric
        TI_ERROR_PwdNotAlpha,

        /// Invalid Password - Cannot be Member ID
        TI_ERROR_PwdEqMember,

        /// Invalid Password - Cannot be Trader Name
        TI_ERROR_PwdEqTrader,

        /// Invalid Password - Cannot include Member Code
        TI_ERROR_PwdMemberCode,

        /// Invalid Password - Must differ from previous password
        TI_ERROR_PwdEqOld,

        /// Invalid Password - Contains Invalid Characters
        TI_ERROR_InvalidChars,

        /// Quote Error - quote does not exist
        TI_ERROR_QuoteNotFound,

        /// Quote Error - size is less than minimum size
        TI_ERROR_QuoteQtyUnderMinLimit,

        /// Quote Error - one or more mandatory fields are missing
        TI_ERROR_QuoteMissingField,

        /// Quote Error - Invalid yield
        TI_ERROR_QuoteInvalidYield,

        /// Quote Error - Bid yield is lower than Ask yield
        TI_ERROR_QuoteYldBidLowerThanAsk,

        /// Quote Error - the request is not valid
        TI_ERROR_QuoteInvalidRequest,

        /// Quote Error - no formula for price-yield conversion
        TI_ERROR_QuoteNoConvFormula,

        /// Quote Error - Invalid Price
        TI_ERROR_QuoteInvalidPrice,

        /// Quote Error - Ask price is lower than Bid price
        TI_ERROR_QuotePrcAskLowerThanBid,

        /// Quote Error - max number of linked quotes exceeded
        TI_ERROR_MaxLinkedQuotesExceeded,

        /// An invalid Trader for Member was specified
        TI_ERROR_TraderMemberMismatch,

        /// Quantity is greater than Sponsor Limit Quantity
        TI_ERROR_SponsorLimitExceeded,

        /// Quote Error - Only FAS Order can be deleted
        TI_ERROR_OnlyFASCanBeDeleted,

        /// Quote Error - VisibleEBM / VisibleDom Qty greater than TotQty
        TI_ERROR_GreaterVisibleQty,

        /// Quote Error - Total Size is not a multiple of Min Increment Size
        TI_ERROR_QtyNotMultiple,

        /// FAS Error - Completely Filled FAS Order cannot be edited
        TI_ERROR_FASCompletelyFilled,

        /// Invalid Currency code
        TI_ERROR_Wrong_Currency,

        /// InvalidFlowType
        TI_ERROR_InvalidFlowType,

        /// Locked Linked Quote Group
        TI_ERROR_LockedLinkedQuoteGroup,

        /// Linked member not found
        TI_ERROR_MemberNotLinked,

        /// Credit Line not found
        TI_ERROR_CreditLineNotFound,

        /// RFQ Invalid Price
        TI_ERROR_RFQInvalidPrice,

        /// Invalid Price Range
        TI_ERROR_InvalidPriceRange,

        /// Invalid Yield Range
        TI_ERROR_InvalidYieldRange,

        /// Invalid Price Tick
        TI_ERROR_InvalidPriceTick,

        /// Invalid Yield Tick
        TI_ERROR_InvalidYieldTick,

        /// Invalid SponsorId
        TI_ERROR_InvalidSponsorId,

        /// Quote Error - Overlapping
        TI_ERROR_QuoteOverlap,

        /// Instrument class suspended on this market
        TI_ERROR_InstClass_Mkt_Suspended,

        /// Section suspended on this market
        TI_ERROR_Section_Mkt_Suspended,

        /// Quote Error - Unable to change Indicative Flag
        TI_ERROR_WrongQuoteIndicativeFlag,

        /// Quote Error - Automatic Only flag not allowed
        TI_ERROR_QuoteAutomaticFlagNotAllowed,

        /// Allocation Error - Invalid collateral for floating rate contract
        TI_ERROR_GCWrongCollateral,

        /// RFQ Error - Recipient is not Logged On
        TI_ERROR_InvalidRFQForRecipientStatus,

        /// Quote Error - max number of linked quotes exceeded
        TI_ERROR_MaximumLinkedQuoteExceeded,

        /// Settlement Error - Trader is not configured on Settlement System
        TI_ERROR_InvalidSettlSystemTrader,

        /// Quote Error - Trader is not logged in
        TI_ERROR_QuoteTraderNotLogged,

        /// Quote Error - Minimum Size is less than Minimum Increment Size
        TI_ERROR_QuoteMinSizeUnderMinIncrLimit,

        /// Quote Error - Size is lower than Minimum Size
        TI_ERROR_QuoteSizeUnderMinLimit,

        /// Quote Error - Size below Minimum Proposal Size
        TI_ERROR_QuoteSizeUnderMinPropLimit,

        /// Invalid Quote - Wrong linked Quote Group
        TI_ERROR_QuoteWrongLinkedQuoteGroup,

        /// Invalid Quote - Linked Quote Group not active
        TI_ERROR_QuoteLinkedQuoteGroupInactive,

        /// Quote Error - max number of linked quotes exceeded
        TI_ERROR_QuoteMaxNumLinkedQuoteExceed,

        /// Action not allowed: mismatch between calendar and Instrument
        TI_ERROR_WrongCalendarIdWithInstr,

        /// Invalid Password - Cannot include trader name
        TI_ERROR_PwdTraderCode,

        /// Action already required
        TI_ERROR_ActionAlreadyRequired,

        /// Parameter mismatch
        TI_ERROR_ParamMismatch,

        /// RFQ Error - RFQ setting type cannot be changed
        TI_ERROR_RFQSettingType,

        /// RFQ Error: Quote message Id missing
        TI_ERROR_RFQQuoteIdMissing,

        /// RFQ Error: Aggressor Id missing
        TI_ERROR_RFQAggrIdMissing,

        /// Invalid RFQ event
        TI_ERROR_RFQInvalidEvent,

        /// RFQ Error - Response required of counterparty
        TI_ERROR_RFQResponseRequired,

        /// RFQ Error - Invalid Size
        TI_ERROR_RFQInvalidSize,

        /// RFQ Error - Unable to change Size
        TI_ERROR_RFQUnableChgSize,

        /// Invalid Quick Edit event
        TI_ERROR_QuickEditInvalidEvent,

        /// Max number of indicative quotes on single instrument exceeded
        TI_ERROR_TooManyIndicativeQuotes,

        /// Credit Risk - Credit Risk limit reached
        TI_ERROR_CreditRiskLimit,

        /// Order Error - No automatic quote is available
        TI_ERROR_NoAutomaticQuoteIsAvailable,

        /// Invalid Order Type
        TI_ERROR_InvalidOrderType,

        /// Wrong Deal Id
        TI_ERROR_WrongDealId,

        /// Invalid event for current deal status
        TI_ERROR_DealInvalidEvent,

        /// Quote Error - Wrong Message Id
        TI_ERROR_WrongQuoteId,

        /// Invalid event for current quote status
        TI_ERROR_QuoteInvalidEvent,

        /// Invalid Quote
        TI_ERROR_InvalidQuote,

        /// Quote Error - Invalid Size Combination
        TI_ERROR_QuoteInvalidSizeComb,

        /// Max number of quotes on single instrument exceeded
        TI_ERROR_QuoteMaxNumberExceed,

        /// Quote Error: Invalid Field Value
        TI_ERROR_QuoteInvalidFieldValue,

        /// Wrong Quote Image
        TI_ERROR_QuoteWrongImage,

        /// Quote is completely Filled
        TI_ERROR_QuoteCompletelyFilled,

        /// Quote Error - Invalid Size
        TI_ERROR_QuoteInvalidSize,

        /// Instrument Class Not Found
        TI_ERROR_ICNotFound,

        /// Account Code Already Present
        TI_ERROR_AccountCodeAlreadyPresent,

        /// Account Not Found
        TI_ERROR_AccountNotFound,

        /// Wrong MultiTrader Master
        TI_ERROR_TraderNotMultiTraderMaster,

        /// Trader Types Must Not Differ
        TI_ERROR_TraderTypeMismatch,

        /// Wrong MultiTrader Slave
        TI_ERROR_TraderNotMultiTraderSlave,

        /// Max Number Of Revoke Actions Exceeded
        TI_ERROR_MaxNumberOfRevokeExceeded,

        /// Trader Already Represented
        TI_ERROR_TraderAlreadyRepresented,

        /// Invalid Instrument Group Description
        TI_ERROR_InvalidDescription,

        /// Instrument Group Description Already Present
        TI_ERROR_DescriptionAlreadyPresent,

        /// Inventory Group does not exist
        TI_ERROR_InventoryGroupNotExistent,

        /// Wrong Member
        TI_ERROR_WrongInventoryGroupMember,

        ///  Exception or No Trading Relation Buy Side and Sell Side Members
        TI_ERROR_TradingRelationNotPresent,

        /// Buy Side already belongs to another Group
        TI_ERROR_BSMembAlreadyAssociated,

        /// Wrong Inventory Group
        TI_ERROR_WrongInventoryGroup,

        /// Wrong Instrument Group
        TI_ERROR_WrongInstrumentGroup,

        /// Wrong Buy Side Member
        TI_ERROR_WrongBSMember,

        /// Inventory Group Is Not Empty
        TI_ERROR_InventoryGroupNotEmpty,

        /// Invalid Withdraw Type
        TI_ERROR_InvalidWithDrawType,

        /// The Trader has no Rights to send this Transaction
        TI_ERROR_InvalidTraderWithType,

        /// Invalid Market
        TI_ERROR_InvalidMarketId,

        /// Invalid Instrument
        TI_ERROR_InvalidInstrument,

        /// Invalid Section
        TI_ERROR_InvalidSection,

        /// Invalid Instrument Class
        TI_ERROR_InvalidInstrumentClass,

        /// Custom Instrument Group Not Found
        TI_ERROR_CustomInstrGrpNotFound,

        /// Invalid Type of Addressee
        TI_ERROR_WrongAddressType,

        /// Invalid Sell Side Member
        TI_ERROR_InvalidSellSideMember,

        /// Sell Side Member not Enabled on this Instrument Class
        TI_ERROR_SellSideMemberNotEnabled,

        /// Sales not Found
        TI_ERROR_MemberSalesNotFound,

        /// Invalid Event Specified for the Trading Relation
        TI_ERROR_TradingRelationInvalidEvent,

        /// Trading Relation not Found
        TI_ERROR_TradingRelationNotFound,

        /// Trading Relation Invalid Status
        TI_ERROR_TradingRelationInvalidStatus,

        /// Invalid Revoke Request
        TI_ERROR_InvalidRevokeRequest,

        /// Invalid Member
        TI_ERROR_NotBuySideMember,

        /// Trade Already Split
        TI_ERROR_TradeAlreadySplit,

        /// Trade Cannot be Split
        TI_ERROR_InvalidSplittableFlag,

        /// Account Excluded By Sell Side Member
        TI_ERROR_AccountExcluded,

        /// Split Quantity not Multiple of Increment Quantity
        TI_ERROR_InvalidQuantityForAccount,

        /// Invalid Resulting Quantity
        TI_ERROR_InvalidNetPositionQuantity,

        /// Invalid Resulting Verb
        TI_ERROR_InvalidNetPositionVerb,

        /// Invalid Instrument Modality Function
        TI_ERROR_InvalidInstrumentModalityFunction,

        /// Invalid Inventory Quote
        TI_ERROR_InvalidInventoryQuote,

        /// Wrong Inventory Quote Id
        TI_ERROR_WrongInventoryQuoteId,

        /// Inventory Quote not found
        TI_ERROR_InventoryQuoteNotFound,

        /// Wrong Inventory Quote Image
        TI_ERROR_WrongInventoryQuoteImage,

        /// Invalid event for current Inventory Quote status
        TI_ERROR_InventoryQuoteInvalidEvent,

        /// Maximum number of Inventory Quote exceeded
        TI_ERROR_MaximumInventoryQuoteExceeded,

        /// Inventory Quote Error - Invalid Minimum Quantity
        TI_ERROR_InventoryQuoteInvalidMinQty,

        /// Inventory Quote Error - Only single side Quote can be deleted
        TI_ERROR_OnlySingleSideCanBeDeleted,

        /// Rfcq not found
        TI_ERROR_RfcqNotFound,

        /// Rfcq Request not found
        TI_ERROR_RfcqRequestNotFound,

        /// Rfcq Order not found
        TI_ERROR_RfcqOrderNotFound,

        /// Rfcq Quote not found
        TI_ERROR_RfcqQuoteNotFound,

        /// Stage Order not found
        TI_ERROR_StageOrderNotFound,

        /// Invalid Rfcq status
        TI_ERROR_InvalidRfcqStatus,

        /// Invalid Rfcq Request status
        TI_ERROR_InvalidRfcqRequestStatus,

        /// Invalid Rfcq Quote status
        TI_ERROR_InvalidRfcqQuoteStatus,

        /// Invalid Rfcq Order status
        TI_ERROR_InvalidRfcqOrderStatus,

        /// Invalid Rfcq Type
        TI_ERROR_InvalidRfcqType,

        /// Rfcq Order pending
        TI_ERROR_RfcqOrderPending,

        /// Rfcq Depth Update Time expired
        TI_ERROR_RfcqDepthUpdateTimeExpired,

        /// Invalid Rfcq Depth Update Time
        TI_ERROR_InvalidRfcqDepthUpdateTime,

        /// Invalid Quotation
        TI_ERROR_InvalidQuotation,

        /// Invalid Settlement Date
        TI_ERROR_InvalidSettlDate,

        /// Invalid Stage Order Member
        T_TI_ERROR_InvalidStageOrderMember,

        /// Invalid Order Stage Status
        TI_ERROR_InvalidOrderStageStatus,

        /// Invalid Order Stage Order Source
        TI_ERROR_InvalidOrderStageOrderSource,

        /// Invalid Order Stage Client Order
        TI_ERROR_InvalidOrderStageClientOrder,

        /// Instrument not found
        TI_ERROR_InstrumentNotFound,

        /// Invalid Order Stage Account
        TI_ERROR_InvalidOrderStageAccount,

        /// Invalid ExecTraderId
        TI_ERROR_InvalidExecTraderId,

        /// Wrong Nominal Value
        TI_ERROR_WrongNominalValue,

        /// Wrong date/offset preview: holiday date
        TI_ERROR_HolidayDate,

        /// Wrong date/offset preview for settlement date
        TI_ERROR_WrongSettlmentDate,

        /// Parameter specified for financial calculator has wrong type
        TI_ERROR_WrongTypeParameter,

        /// Mandatory parameter for financial calculator not present
        TI_ERROR_MandatoryParameter,

        /// Wrong Function specified for financial calculator
        TI_ERROR_WrongFunctionId,

        /// Maximum number of inventory group exceeded
        TI_ERROR_InvGroupLimitExceeded,

        /// No further action allowed for this buy side member
        TI_ERROR_InvGroupMemberLimitExceeded,

        /// Instrument Group Definition Not Present
        TI_ERROR_InstrGrpDefNotFound,

        /// Custom Instrument Group Definition Not Present
        TI_ERROR_CustomInstrGrpDefNotFound,

        /// Wrong Parent Group
        TI_ERROR_WrongParentId,

        /// Wrong Group Level
        TI_ERROR_WrongGroupLevel,

        /// Instrument Group Is Not Empty
        TI_ERROR_ParentGroupIdNotEmpty,

        /// Too few instruments for this rfcq type
        TI_ERROR_TooFewRfcqInstruments,

        /// Invalid Order Stage Order Type
        TI_ERROR_InvalidOrderStageOrderType,

        /// SecurityId not found
        TI_ERROR_SecurityIdNotFound,

        /// Order Stage Wrong Image
        TI_ERROR_OrderStageWrongImage,

        /// Invalid Order Stage ExecutionType
        TI_ERROR_InvalidOrderStageExecutionType,

        /// Invalid Order Stage Number of Leg
        TI_ERROR_InvalidOrderStageNumberOfLeg,

        /// Cannot settle at T+0
        TI_ERROR_InvalidTPZeroSettlement,

        /// Member cannot settle at T+0
        TI_ERROR_InvalidMemberTPZeroSettlement,

        /// Cannot settle at T+0 - CutOff expired
        TI_ERROR_InvalidCutOffTPZeroSettlement,

        /// Instrument Group Already Deleted
        TI_ERROR_InstrumentGroupAlreadyDeleted,

        /// Stage Order locked by another trader
        I_ERROR_StageOrderLockedByAnotherTrader,

        /// Wrong Instrument per Instrument Class
        TI_ERROR_InvalidInstrumentPerClass,

        /// Wrong Trading Modality
        TI_ERROR_InvalidTradingModality,

        /// Section closed on this market
        TI_ERROR_Section_Mkt_Closed,

        /// Instrument Group Not Empty
        TI_ERROR_InstrumentGroupNotEmpty,

        /// Stage Order is already locked
        TI_ERROR_StageOrderAlreadyLocked,

        /// Wild Card Not Allowed
        TI_ERROR_WildCardNotAllowed,

        /// MaxFilteredIC Reached
        TI_ERROR_MaxFilteredICReached,

        /// MaxFilteredTradable Reached
        TI_ERROR_MaxFilteredTradableReached,

        /// Instrument Group Has Active Subgroups
        TI_ERROR_GroupHasActiveSubgroups,

        /// Invalid Quantity Range
        TI_ERROR_InvalidQtyRange,

        /// Invalid Quantity Tick
        TI_ERROR_InvalidQtyTick,

        /// Invalid Price
        TI_ERROR_InvalidPrice,

        /// Invalid Yield
        TI_ERROR_InvalidYield,

        /// Client Existing In A Group
        TI_ERROR_ClientExistingInAGroup,

        /// Rfcq Quote Not Found In Frozen Book
        TI_ERROR_RfcqQuoteNotFoundInFrozenBook,

        /// BPV Not Available
        TI_ERROR_BPVNotAvailable,

        /// Default Bond configuration disabled for this GC Basket
        TI_ERROR_InvalidGCBondDefinitionType,

        /// Mismatch Error - Wrong Message ID
        TI_ERROR_ChatAlreadyPresent,

        /// Message Error - Minimum number of recipients unavailable
        TI_ERROR_RecipientNotAddressable,

        /// Message Error - Recipient not logged
        TI_ERROR_RecipientNotLogged,

        /// Message Error - Recipient Messaging Disabled
        TI_ERROR_RecipientNoRights,

        /// Message Error - Messaging Disabled
        TI_ERROR_SenderNotAllowed,

        /// Default Bond must be CCP Eligible
        TI_ERROR_CCPEligibleFlagMustBeYes,

        /// Mismatch Error - Wrong Message ID
        TI_ERROR_WrongChatIdRequest,

        /// Mismatch Error - Wrong Member ID for Message
        TI_ERROR_SenderNotOwner,

        /// Message Error - Message already closed
        TI_ERROR_TxnExpired,

        /// Message Error - Message not permitted
        TI_ERROR_WrongMemberType,

        /// Mismatch Error - Wrong Transaction ID for Message
        TI_ERROR_WrongRefTxn,

        /// Mismatch Error - Wrong Member ID for Message
        TI_ERROR_SenderNotAllowedOnRefTxn,

        /// Message Error - Message Session already closed
        TI_ERROR_ChatClosed,

        /// Message Error - Message Session already closed
        TI_ERROR_TxnFinalState,

        /// Message Error - Message Session already closed
        TI_ERROR_ClosingMessagePresent,

        /// Mismatch Error - Wrong Message Action
        TI_ERROR_CloginMsgNotAllowedForChat,

        /// Message Error - Message cannot be closed yet
        TI_ERROR_TxnNotFinalState,

        /// Input Error - Incomplete Field
        TI_ERROR_BlockedMemberMissing,

        /// Input Error - Invalid selection, bilateral trading not allowed
        TI_ERROR_InvalidBilateralFlag,

        /// Mismatch Error - Wrong OTC ID
        TI_ERROR_WrongMsgId,

        /// Trading Error - Bilateral trading cut-off elapsed
        TI_ERROR_BilateralTradingNotAllowed,

        /// RFQ Error - Recipient has disabled RFQs
        TI_ERROR_RFQExclusion,

        /// GC Error- Default Bond for auto allocation must be defined first
        TI_ERROR_DefaultGCInvalid,

        /// Internal Error - Repo GC Quantity Limit Not Found
        TI_ERROR_RepoGCQuantityLimitNotFound,

        /// Mismatch Error - Invalid Account
        TI_ERROR_AccountNotActive,

        /// Internal Error - Market Parameter Not Found
        TI_ERROR_MarketParameterNotFound,

        /// Input Error - Incomplete Field
        TI_ERROR_OriginatorTraderNotFound,

        /// Input Error - Incomplete Field
        TI_ERROR_CounterpartTraderNotFound,

        /// Input Error - Invalid Counterparty
        TI_ERROR_WrongSubmitter,

        /// Allocation Error - Number of tickets exceeds rules of allocation
        I_ERROR_MaxNumberSecurityLimitGC,

        /// Allocation Error - Maximum Number of tickets exceeded
        TI_ERROR_OutLimitsAllocationQtyGC,

        /// Configuration Error - Invalid Settlement group configuration
        TI_ERROR_InvalidSettlementMode,

        /// Input Error - Invalid Flag Integer
        TI_ERROR_InvalidTransparentFlag,

        /// Daily inflation rate not found
        TI_ERROR_DailyInflationRateNotFound,

        /// Pre allocation total quantity different from RFCQ quantity
        TI_ERROR_InvalidAllocationTotalQuantity,

        /// Invalid allocation status
        TI_ERROR_InvalidAllocationStatus,

        /// Allocation code already present
        TI_ERROR_AllocationCodeAlreadyPresent,

        /// Pre allocation not found
        TI_ERROR_AllocationNotFound,

        /// Mismatch Error - Wrong Member ID
        TI_ERROR_InvalidRecipientForTxn,

        /// Mismatch Error - Wrong Member ID
        TI_ERROR_InvalidRecipientTraderForTxn,

        /// Input Error - instrument may only be traded bilaterally
        TI_ERROR_CCPNotAvailableForInstrument,

        /// Max number of sell side members exceeded
        TI_ERROR_MaxSellSideNumberExceeded,

        /// Cannot exclude all RFCQ types with an accepted trading relation
        TI_ERROR_AllRFCQTypeExcluded,

        /// Quote Error - Ask quote is lower than Bid quote
        TI_ERROR_QuoteYldAskLowerThanBid,

        /// Pre allocation side different from RFCQ side
        TI_ERROR_InvalidAllocationVerb,

        /// Exceptions limit exceeded
        TI_ERROR_ExceptionsLimitExceeded,

        /// RFCQ Double Side - Member not enabled
        TI_ERROR_RFCQDoubleSideNotEnabled,

        /// Invalid trading list
        TI_ERROR_InvalidTradingList,

        /// Trading list - Invalid Leg ID
        TI_ERROR_InvalidTradingListLeg,

        /// Trading list not found
        TI_ERROR_TradingListNotFound,

        /// Trading list leg not found
        TI_ERROR_TradingListLegNotFound,

        /// Mismatch Error - Wrong Member ID in trading list 
        TI_ERROR_TradingListWrongMember,

        /// Mismatch Error - Wrong Trader ID in trading list
        TI_ERROR_TradingListWrongTrader,

        /// Trading list - Invalid status
        TI_ERROR_TradingListInvalidStatus,

        /// Trading list - Invalid leg status
        TI_ERROR_TradingListInvalidLegStatus,

        /// Trading list - Invalid leg
        TI_ERROR_TradingListInvalidLegs,

        /// Stage Order - Cannot modify Stage Order in Trading List
        TI_ERROR_StageOrderInTradingList,

        /// Stage Order - Stage Order already used in Trading List
        TI_ERROR_StageOrderUsedInTradingList,

        /// Invalid Rfcq DueInTime
        TI_ERROR_InvalidRfcqDueInTime,

        /// Number of quotes for auto-match inconsistent
        TI_ERROR_InvalidIOI,

        /// Trading list - Invalid leg quantity
        TI_ERROR_TradingListInvalidLegQty,

        /// Trading list - Invalid total quantity
        TI_ERROR_TradingListInvalidTotalQty,

        /// Trading list - Invalid number of legs
        TI_ERROR_TradingListInvalidNumOfLegs,

        /// Trading list - Wrong instrument type
        TI_ERROR_TradingListWrongInstrType,

        /// Disclose and quotation flags mismatching
        TI_ERROR_DiscloseIOIMismatchingFlags,

        /// Stage Order - Inconsistent link ID
        TI_ERROR_StageOrderWrongLinkIdInTradingList,

        /// Trading list - Invalid private allocation link
        TI_ERROR_TradingListInvalidLink,

        /// Invalid allocation ID
        TI_ERROR_InvalidAllocationId,

        /// Exchange rate not found
        TI_ERROR_ExchangeRateNotFound,

        /// Firm quotation disabled
        TI_ERROR_FirmQuotingDisabled,

        /// Indicative quotation disabled
        TI_ERROR_IndicativeQuotingDisabled,

        /// Striker quotation disabled
        TI_ERROR_StrikerQuotingDisabled,

        /// Quote Error - Invalid striker quotation flag
        TI_ERROR_InvalidStrikerQuotationFlag,

        /// Quote Error - Invalid striker Price
        TI_ERROR_QuoteInvalidStrikerPrice,

        /// Invalid striker Price Range
        TI_ERROR_InvalidStrikerPriceRange,

        /// Quote Error - Invalid striker yield
        TI_ERROR_QuoteInvalidStrikerYield,

        /// Invalid striker quantity
        TI_ERROR_InvalidStrikerQty,

        /// FAS Order total quantity less than minimum size
        TI_ERROR_MidPriceFASTotalQtyUnderLimit,

        /// FAS Order min execution quantity less than minimum size
        TI_ERROR_MidPriceFASMinExQtyUnderLimit,

        /// FAS Order total quantity less than min execution quantity
        TI_ERROR_MidPriceFASTotalQtyUnderMES,

        /// FAS Order total quantity is not a multiple of Min Increment Size
        TI_ERROR_MidPriceFASTotalQtyNotMultiple,

        /// FAS Order min exec qty is not a multiple of Min Increment Size
        TI_ERROR_MidPriceFASMinExQtyNotMultiple,

        /// Maximum number of FAS Order exceeded
        TI_ERROR_MidPriceMaximumFASOrderExceeded,

        /// Wrong FAS Order Image
        TI_ERROR_MidPriceFASOrderWrongImage,

        /// FAS Order - Overlapping
        TI_ERROR_MidPriceFASOrderOverlap,

        /// FAS Order - Invalid limit quotation
        TI_ERROR_MidPriceFASOrderInvalidLimitQuotation,

        /// FOK Order - Section not enabled
        TI_ERROR_MidPriceFOKOrderSectionNotEnabled,

        /// Inventory group member invalid combination
        TI_ERROR_InventoryGroupMemberInvalidComb,

        /// Max number of buy side member in a group exceeded
        TI_ERROR_MaxNumberOfMemberInAGroup,

        /// Max number of inventory group member configuration exceeded
        TI_ERROR_MaxNumberOfInvGroupConfig,

        /// Max number of inventory group member exceptions exceeded
        TI_ERROR_MaxNumberOfInvGroupExceptions,

        /// Max number of inventory dealer group configuration exceeded
        TI_ERROR_MaxNumberOfInvDealerGroupConfig,

        /// Invalid minimum execution quantity
        TI_ERROR_InvalidMinExecQty,

        /// Exe Order stop - min time between same orders applied
        TI_ERROR_DenialCounterParty,

        /// Executable Order - Inventory quote not executable
        TI_ERROR_InventoryQuoteIsOnlyIndicative,

        /// Executable Order - Previous order still processing
        TI_ERROR_InventoryOrderProcessing,

        /// FAS Order Min Executable Quantity above cap of Min Qty
        TI_ERROR_MidPriceFASMinExQtyOverCapLimit,

        /// Quote Error - Axe flag allowed only in bid or ask
        TI_ERROR_InvalidAxedBondFlags,

        /// OTC: brokerage organization code not found
        TI_ERROR_BrokerCodeNotFound,

        /// OTC: broker code not compliant
        TI_ERROR_BrokerCodeNotCompliant,

        /// Authentication Failed
        TI_ERROR_AuthenticationFailed,

        /// Account Excluded By Buy Side Member
        TI_ERROR_BuySideAccountExcluded,

        /// OTC: broker code can not be modified
        TI_ERROR_BrokerCodeInvalidEdit,

        /// Max number of Cash Offer exceeded
        TI_ERROR_MaxNumACMCashOfferExceeded,

        /// Max number of Collateral Offer exceeded
        TI_ERROR_MaxNumACMCollateralOfferExceeded,

        /// Cash Offer not found
        TI_ERROR_ACMCashOfferNotFound,

        /// Collateral Offer not found
        TI_ERROR_ACMCollateralOfferNotFound,

        /// Wrong Transaction Image
        TI_ERROR_WrongTransactionImage,

        /// Collateral Offer Quantity exceeds Cash Offer Quantity
        TI_ERROR_ACMCashOfferQtyExceeded,

        /// Only BrokerPlus is allowed for this action
        TI_ERROR_OnlyFromBrokerPlus,

        /// Disabling not allowed for this message
        TI_ERROR_DisablingNotAllowed,

        /// Invalid EOI Message Type
        TI_ERROR_EoiMsgTypeUnkown,

        /// No recipient allowed on this section/instrument
        TI_ERROR_NoRecipientAllowed,

        /// Referenced message not found
        TI_ERROR_NoReferencedMsg,

        /// Only one recipient is allowed in response
        TI_ERROR_OnlyOneRecipient,

        /// Referenced message was cancelled
        TI_ERROR_EoiMsgCancelled,

        /// Referenced message not active
        TI_ERROR_EoiMsgNotActive,

        /// Datafeed not allowed for this message/action
        TI_ERROR_DataFeedNotAllowed,

        /// Generic Eoi cannot be blind
        TI_ERROR_EoiGenericNotBlind,

        /// Stage Order - Partial fill not allowed
        TI_ERROR_StageOrderPartiallyFilled,

        /// BV Best Group Definition already present
        TI_ERROR_BVBestGroupAlreadyPresent,

        /// BV Best Group Definition for sellside already present
        TI_ERROR_BVBestSellSideAlreadyPresent,

        /// MTS Certification only possible by trader config
        TI_ERROR_MTSCertificationNotAllowed,

        /// Activation only allowed together with certification
        TI_ERROR_ActivationAllowedWithCertification,

        /// First Name cannot be empty
        TI_ERROR_FirstNameEmpty,

        /// Last Name cannot be empty
        TI_ERROR_LastNameEmpty,

        /// Email cannot be empty
        TI_ERROR_EmailEmpty,

        /// Phone cannot be empty
        TI_ERROR_PhoneEmpty,

        /// Residual maturity not found
        TI_ERROR_ResidualMaturityNotFound,

        /// Price or Yield must be mandatory
        TI_ERROR_PriceOrYieldMandatory,

        /// Univocity cash offer account violated
        TI_ERROR_ACMUnivocityAccountViolated,

        /// Collateral Offer balance exceeded
        TI_ERROR_ACMCollateralOfferBalanceExceeded,

        /// Cash Offer balance exceeded
        TI_ERROR_ACMCashOfferBalanceExceeded,

        /// Missing Account for current transaction
        TI_ERROR_AccountMandatory,

        /// Found Member Account exception
        TI_ERROR_AccountException,

        /// Invalid Account Type
        TI_ERROR_InvalidAccountType,

        /// Note field cannot be empty
        TI_ERROR_EmptyNote,

        /// Repo ACM Triparty Note not found
        TI_ERROR_TripartyNoteNotFound,

        /// Triparty id not found
        TI_ERROR_WrongTriparty,

        /// Counterparty not owner of account
        TI_ERROR_CounterpartyNotAccountOwner,

        /// Action not allowed in the current date
        TI_ERROR_ActionNotAllowedInCurrentDate,

        /// Invalid Trading Type
        TI_ERROR_InvalidTradingType,

        /// Invalid Area Code
        TI_ERROR_InvalidAreaCode,

        /// Counterparty is mandatory
        TI_ERROR_CounterpartyMandatory,

        /// Period not in market open plus delay
        TI_ERROR_PeriodNotInMarketOpen,

        /// No pair exists with this section and instrumentClass
        TI_ERROR_NoPairFoundSectionIC,

        /// Invalid fixing period time
        TI_ERROR_InvalidFixingTime,

        /// Invalid fixing period date
        TI_ERROR_InvalidFixingDate,

        /// Invalid action for fixing interval in execution
        TI_ERROR_InvalidActionFixingInterval,

        /// Expired fixing interval
        TI_ERROR_ExpiredFixingInterval,

        /// Stage Order Execution not allowed
        TI_ERROR_StageOrderExecNotAllowed,

        /// Specific setting not allowed while wildcard existing
        TI_ERROR_WildCardExisting,

        /// MarkUpValue not compliant with tick
        TI_ERROR_InvalidMarkUpValue,

        /// Invalid field value for this trading modality
        TI_ERROR_InvalidFieldForTradingModality,

        /// Unseasoned not enabled
        TI_ERROR_UnseasonedNotEnabled,

        /// Trade dates suspended on this section
        TI_ERROR_Section_Dates_Suspended,

        /// Trade dates suspended on this instrument class and section
        TI_ERROR_Section_InstClass_Dates_Suspended,

        /// Invalid Rate Range
        TI_ERROR_InvalidRateRange,

        /// Invalid Rate Tick
        TI_ERROR_InvalidRateTick,

        /// Quote Error - Invalid Rate
        TI_ERROR_QuoteInvalidRate,

        /// Quote Error - Ask rate is lower than Bid rate
        TI_ERROR_QuoteRateAskLowerThanBid,

        /// Invalid tradable object
        TI_ERROR_InvalidTradableObject,

        /// Invalid pair section and tradable object
        TI_ERROR_InvalidSectionForTradableObject,

        /// Invalid pair instrument class and tradable object
        TI_ERROR_InvalidICForTradableObject,

        /// Mnemonic already exists
        TI_ERROR_MnemonicAlreadyExists,

        /// Member and Client specified are not in sponsor relationship
        TI_ERROR_SponsorRelationNotFound,

        /// First dealer in list is not the preferred dealer
        TI_ERROR_FirstDealerNotPreferred,

        /// Num of dealers exceeds maximum
        TI_ERROR_MaxDealersExcedeed,

        /// Record not found
        TI_ERROR_RecordNotFound,

        /// Record already present
        TI_ERROR_RecordAlreadyPresent,

        /// AreaCodeRelation not found
        TI_ERROR_AreaCodeRelNotFound,

        /// Min number of sell side members not reached
        TI_ERROR_MinSellSideNumberNotReached,

        /// Dealer not allowed on rfcq respond
        TI_ERROR_DealerNotAllowedOnRFCQRespond,

        /// Num of dealers declared different from dealers list
        TI_ERROR_InvalidNumOfDealers,

        /// Num of dealers cannot be zero
        TI_ERROR_ZeroNumOfDealers,

        /// Minimum number of dealers not reached
        TI_ERROR_MinimumDealersUnreached,

        /// Minimum number of Matching Quotes not reached
        TI_ERROR_MinMatchingQuotesNotReached,

        /// No dealer in Preferred list
        TI_ERROR_NoDealerInPreferredList,

        /// Max number of change profile type reached
        TI_ERROR_MaxReactivationReached,

        /// Profile type not recognized
        TI_ERROR_InvalidProfileType,

        /// Configuration for instrument class exists
        TI_ERROR_InstrumentClassExists,

        /// Configuration with wildcard exists
        TI_ERROR_WildCardExists,

        /// Invalid Submitter Member Id
        TI_ERROR_WrongSubmitterMember,

        /// Wrong Duration
        TI_ERROR_WrongDuration,

        /// Group id not found
        TI_ERROR_GroupIdNotFound,

        /// Max num tier group configuration reached
        TI_ERROR_MaxNumTierGroupConfigurations,

        /// Max num tier group exception reached
        TI_ERROR_MaxNumTierGroupException,

        /// Wrong CVA
        TI_ERROR_WrongCVA,

        /// Member not enabled to override CVA
        TI_ERROR_MemberNotEnableToOverrideCVA,

        /// TPA Visibility not permitted
        TI_ERROR_WrongTPAVisibility,

        /// Trading on behalf not allowed
        TI_ERROR_TradingOnBehalfNotAllowed,

        /// Inventory Quote Error - VisibleQty greater than TotQty
        TI_ERROR_GreaterInventoryVisibleQty,

        /// TPA member certification not allowed without mnemonic
        TI_ERROR_CertificationWithoutMnemonic,

        /// Tier Group is associated to TPA Member
        TI_ERROR_TierGroupAssociatedToTPA,

        /// Maximum number of Trading Idea exceeded
        TI_ERROR_MaxNumOfTradingIdeaExceeded,

        /// Visible Size is not a multiple of Min Increment Size
        TI_ERROR_VisibleQtyNotMultiple,

        /// Standard tradable object already exists
        TI_ERROR_TradableObjectDuplicated,

        /// Maximum number of Broken Dates exceeded
        TI_ERROR_MaxNumOfBrokenDatesExceeded,

        /// Instrument class suspended on this section
        TI_ERROR_InstClassSectionMktSuspended,

        /// Quantity is greater than CAP Quantity Limit
        TI_ERROR_CAPQuantityLimit,

        /// Invalid Mark-Up Type
        TI_ERROR_InvalidMarkUpType,

        /// Missing Max Quantity value zero for Mark-Up Threshold
        TI_ERROR_MissingMaxQtyZero,

        /// Mutually exclusive Mark-Up configuration already present
        TI_ERROR_InvalidMarkUpConfiguration,

        /// Invalidy Mark-Up Max Quantity Order
        TI_ERROR_InvalidMarkUpMaxQtyOrder,

        /// Invalid request: number of treshold declared different from list
        TI_ERROR_NumThresholdDiffFromList,

        /// Transaction not allowed on this instrument class
        TI_ERROR_TransactionNotAllowedOnIC,

        /// Invalid Discount Rate
        TI_ERROR_InvalidDRate,

        /// Invalid Discount Rate Tick
        TI_ERROR_InvalidDRateTick,

        /// Invalid Discount Rate Range
        TI_ERROR_InvalidDRateRange,

        /// Quote Error - Invalid discount rate
        TI_ERROR_QuoteInvalidDRate,

        /// Quote Error - Bid discount rate is lower than Ask discount rate
        TI_ERROR_QuoteDRateBidLowerThanAsk,

        /// Dealer not enabled
        TI_ERROR_DealerNotEnabled,

        /// Buy Side Member cannot be included in DealerList
        TI_ERROR_BuySideMemberInDealerList,

        /// Maximum IOI Exceeded
        TI_ERROR_MaximumIOIExceeded,

        /// Wrong IOI Image
        TI_ERROR_WrongIOIImage,

        /// RFCQ Error - Invalid Quantity
        TI_ERROR_RFCQInvalidQty,

        /// RFCQ Error - Unable to change Quantity
        TI_ERROR_RFCQWrongQtyChange,

        /// ProductType and Currency admitted only with wildcard for Broker
        TI_ERROR_WildcardBroker,

        /// Empty Depth - No dealer available for preview
        TI_ERROR_EmptyDepth,

        /// Curve Identifier not found
        TI_ERROR_CurveNotFound,

        /// IOI Client Identifier already present
        TI_ERROR_IOIClientIdentifierAlreadyPresent,

        /// Action not allowed for members with NCL
        TI_ERROR_MembersNCL,

        /// Action not allowed for ApplyHaircutFlag No
        TI_ERROR_ApplyHaircutFlagNo,

        /// Action not allowed for Haircut in Status Deleted
        TI_ERROR_HaircutStatusDeleted,

        /// Mutually Exclusive Configuration already present
        TI_ERROR_MutuallyExclusiveConfiguration,

        /// Invalid Haircut Value
        TI_ERROR_InvalidHaircutValue,

        /// Invalid Haircut Type
        TI_ERROR_InvalidHaircutType,

        /// Residual Maturity not allowed for this Instrument class Type
        TI_ERROR_InvalidResMatOnIC,

        /// Invalid Credit Profile
        TI_ERROR_InvalidCreditProfile,

        /// Invalid Member Type
        TI_ERROR_InvalidMemberType,

        /// Invalid Member Type Combination
        TI_ERROR_InvalidMemberTypeCombination,

        /// Invalid Spread Value
        TI_ERROR_InvalidSpreadValue,

        /// Invalid Haircut Status
        TI_ERROR_InvalidHaircutStatus,

        /// Quantity Not Editable
        TI_ERROR_QuantityNotEditable,

        /// Settlement System not enabled to Haircut functionality
        TI_ERROR_SettlSystemNotEnabledToHaircut,

        /// Instrument and Currency trading combination already present
        TI_ERROR_InstCurrencyAlreadyPresent,

        /// Transaction size in breach of Warning maximum size constraints
        TI_ERROR_WarningMessageOnSize,

        /// Transaction size in breach of Blocking maximum size constraints
        TI_ERROR_BlockingMessageOnSize,

        /// Transaction rate in breach of minimum or maximum rate variance constraints
        TI_ERROR_WarningMessageOnRate,

        /// Transaction Size and Rate in breach of minimum or maximum constraints
        TI_ERROR_WarningMessageOnSizeAndRate,

    };

    /// Provides string presentation
    static std::string toString (Enum value);
};




}
}
}
}