"Changelog query provides an overview of changes implemented to the API"
type Changelog {
  "Date of implemented changes"
  Date: Date
  "Type of change"
  Type: String
  "Name or content of previuos value"
  OldValue: String
  "Name or content of new value"
  NewValue: String
  "Description of the change"
  Description: String
  "Affected table/query"
  Query: String
}

"The provided filter for the Changelog entity "
input ChangelogFilter {
  Date: DateFilter
  Type: StringFilter
  OldValue: StringFilter
  NewValue: StringFilter
  Description: StringFilter
  Query: StringFilter
}

"The response type of the Changelog entity "
type ChangelogResponse {
  "Submission date of the data"
  date: Date
  "list of Changelog items."
  data: [Changelog]
}

"Contracts query provides basic information about instruments traded on EUREX"
type Contracts {
  "ID of the product."
  ProductID: Int
  "Product symbol."
  Product: String
  "Future or Option discriminator."
  ProductLine: String
  "Unique ID used in T7 ETI for trading requests."
  InstrumentID: Int
  "Eurex’s cross-systems numeric unique internal ID of the contract."
  ContractID: Int
  "ISIN code related to Eurex’s contracts."
  ISIN: String
  "Represents a frame for multiple unique contracts with same basic properties, in case of a future product master contract is equal to the standard contract"
  MasterContract: String
  "Eurex's unique business name of the contract. The Contract represents the key fields of a Contract in a string form. It contains the following key Contract attributes which identify a contract uniquely, separated by spaces: Product symbol or Product ID, Contract Type, Contract Date, Settlement Type, Exercise Style, C/P Indicator, Strike Price and Contract Version Number. Key words definition: SI - Standard Instrument (Regular Contract), FI - Flexible Instrument (Flexible Contract), CS - Cash Settlement, PS - Physical Settlement (Non-Cash), EU - European Exercise Style (Options) and AM - American Exercise Style (Options). The content of this field may change in exceptional circumstances. These include among others - Capital Adjustments, which change the contained strike price or changes of the Trading Calendar, which might change the contained contract date."
  Contract: String
  "Defines, if this contract based on its contract generation cycle, is considered primary."
  PrimaryContract: String
  "Indicates expiration type, in the context of which the instrument has been created by the exchange. E.g. yearly, quarterly, monthly etc. expiration types"
  ContractCycle: String
  "Defines if instrument is a put (P) or call (C)."
  CallPut: String
  "Contract Strike price."
  Strike: Float
  "The field contains the original strike price before modifcation of the contract."
  OriginalStrike: Float
  "Defines the type of settlement for a contract"
  SettlementType: String
  "Exercise style of a contract"
  ExerciseStyle: String
  "Identifies variation of the standard instruments due to corporate action."
  VersionNr: Int
  "Represents the number of capital adjustments applied during the product lifetime"
  GenerationNr: Int
  "Contract size of a contract"
  ContractSize: Float
  "Contract size which is going to be settled or delivered"
  DeliverySize: Float
  "Fraction of contract size which is cash settled in case contract is physically settled"
  CashFraction: Float
  "Indicates the type of security using ISO 10962 standard."
  CFI: String
  "First trading day of the contract."
  FirstTradingDate: Date
  "Date used to identify the instrument (YYYYMMDD) and referring to the main event of derivative contract."
  ContractDate: Date
  "A symbol to describe the type of ContractDate."
  ContractDateType: String
  "Last trading day of the contract."
  LastTradingDate: Date
  "Expiry date of the contract."
  ExpirationDate: Date
  "Final settlement price fixing date."
  FinalSettlementDate: Date
  "Previous day’s settlement price. Provided in clearing notation for variance futures and total return futures instruments"
  PreviousDaySettlementPrice: Float
  "Previous day’s option delta provided for option instruments only"
  OptionsDelta: Float
  "Underlying contract for derivatives on derivatives (e.g.: Options on futures) "
  UnderlyingContract: String
}

"The provided filter for the Contracts entity "
input ContractsFilter {
  ProductID: IntFilter
  Product: StringFilter1!
  ProductLine: StringFilter
  InstrumentID: IntFilter
  ContractID: IntFilter
  ISIN: StringFilter
  MasterContract: StringFilter
  Contract: StringFilter
  PrimaryContract: StringFilter
  ContractCycle: StringFilter
  CallPut: StringFilter
  Strike: FloatFilter
  OriginalStrike: FloatFilter
  SettlementType: StringFilter
  ExerciseStyle: StringFilter
  VersionNr: IntFilter
  GenerationNr: IntFilter
  ContractSize: FloatFilter
  DeliverySize: FloatFilter
  CashFraction: FloatFilter
  CFI: StringFilter
  FirstTradingDate: DateFilter
  ContractDate: DateFilter
  ContractDateType: StringFilter
  LastTradingDate: DateFilter
  ExpirationDate: DateFilter
  FinalSettlementDate: DateFilter
  PreviousDaySettlementPrice: FloatFilter
  OptionsDelta: FloatFilter
  UnderlyingContract: StringFilter
}

"The response type of the Contracts entity "
type ContractsResponse {
  "Submission date of the data"
  date: Date
  "list of Contracts items."
  data: [Contracts]
}

"Date in extended ISO 8601 format: YYYY-MM-DD"
scalar Date

input DateFilter {
  ne: Date
  eq: Date
  le: Date
  lt: Date
  ge: Date
  gt: Date
  between: [Date]
}

input DateFilter1 {
  eq: Date!
}

"The table provides essential data on the bonds which meet the criteria of eligibility for the deliverable baskets of Eurex’s Fixed Income Government bond futures. The data provided includes bonds key parameters, such as the expiry date and the coupon rate, as well as their respective conversion factors."
type DeliverableBonds {
  "Product symbol."
  Product: String
  "Date used to identify the contract, in most cases it is expiry date of the contract"
  ContractDate: Date
  "Eurex’s cross-systems numeric unique internal ID of the contract."
  ContractID: Int
  "ISIN code related to Eurex’s contracts"
  ContractISIN: String
  "Eurex's unique business name of the contract."
  Contract: String
  "ISIN of underlying Bonds eligible for the deliverable baskets of the futures contract"
  BondISIN: String
  "Name of underlying Bonds eligible for the deliverable baskets of the futures contract"
  BondName: String
  "Coupon rate expressed in percentage points of underlying Bonds eligible for the deliverable baskets of the futures contract"
  BondCouponRate: Float
  "Maturity date of underlying Bonds eligible for the deliverable baskets of the futures contract"
  BondMaturityDate: Date
  "Conversion Factor of underlying Bonds eligible for the deliverable baskets of the futures contract"
  ConversionFactor: Float
}

"The provided filter for the DeliverableBonds entity "
input DeliverableBondsFilter {
  Product: StringFilter
  ContractDate: DateFilter
  ContractID: IntFilter
  ContractISIN: StringFilter
  Contract: StringFilter
  BondISIN: StringFilter
  BondName: StringFilter
  BondCouponRate: FloatFilter
  BondMaturityDate: DateFilter
  ConversionFactor: FloatFilter
}

"The response type of the DeliverableBonds entity "
type DeliverableBondsResponse {
  "Submission date of the data"
  date: Date
  "list of DeliverableBonds items."
  data: [DeliverableBonds]
}

"Enlight query provides product configuration for Eurex EnLight service"
type Enlight {
  "ID of the product."
  ProductID: Int
  "Product symbol."
  Product: String
  "Minimum number of responders for anonymous negotiation event on Eurex Enlight. Only business units that are different from the requesters are counted, and responders of the same business unit is only counted once against the threshold."
  AnonymousMinNoOfRespondents: Int
  "Minimum number of responders for non-anonymous negotiation event on Eurex Enlight. Only business units that are different from the requesters are counted, and responders of the same business unit is only counted once against the threshold."
  MinNoOfRespondents: Int
  "Specifies the factor by which the tick size can be reduced with a synthetic deal on Eurex EnLight."
  SubTickFactor: Float
  "Specifies the default duration of a negotiation in seconds on Eurex EnLight."
  NegotiationDuration: Int
  "Specifies the delay in seconds between agreeing a deal in Eurex Enlight and the time before submitting it to TES."
  STPDelayDuration: Int
  "Specifies the maximum duration of a negotiation in seconds on Eurex EnLight."
  MaxRFQExpiryTime: Time
}

"The provided filter for the Enlight entity "
input EnlightFilter {
  ProductID: IntFilter
  Product: StringFilter
  AnonymousMinNoOfRespondents: IntFilter
  MinNoOfRespondents: IntFilter
  SubTickFactor: FloatFilter
  NegotiationDuration: IntFilter
  STPDelayDuration: IntFilter
  MaxRFQExpiryTime: TimeFilter
}

"EnlightResponders query provides list of Enlight responders per product"
type EnlightResponders {
  "ID of the product"
  ProductID: Int
  "Product symbol"
  Product: String
  "User ID of the user who responds to RfQs on the product"
  Respondent: String
  "Indicates if a responder is listed as an Enlight SMART respondent"
  SmartRespondent: String
}

"The provided filter for the EnlightResponders entity "
input EnlightRespondersFilter {
  ProductID: IntFilter
  Product: StringFilter
  Respondent: StringFilter
  SmartRespondent: StringFilter
}

"The response type of the EnlightResponders entity "
type EnlightRespondersResponse {
  "Submission date of the data"
  date: Date
  "list of EnlightResponders items."
  data: [EnlightResponders]
}

"The response type of the Enlight entity "
type EnlightResponse {
  "Submission date of the data"
  date: Date
  "list of Enlight items."
  data: [Enlight]
}

"Expirations query provides expirations information on contract level"
type Expirations {
  "ID of the product."
  ProductID: Int
  "Product symbol."
  Product: String
  "A standardized identifier that represents the blueprint of a derivative contract, defining the invariant master‑level attributes of a contract family from which tradable derivative contracts are derived."
  MasterContract: String
  "Last trading day of the contract."
  LastTradingDate: Date
  "Expiry date of the contract."
  ExpirationDate: Date
  "Expiry day of contract."
  ExpDay: Int
  "Expiry month of contract."
  ExpMonth: Int
  "Expiry year of contract."
  ExpYear: Int
  "Weeknumber in context of a month."
  MonthWeek: Int
  "Weekday."
  Weekday: String
  "Weeknumber in context of a year (Calendarweek)."
  WeekNumber: Int
  "Number of calendar days before expiration "
  DaysToExpiration: Int
  "Trading days offset between expiration and last trading dates"
  LTDOffset: String
  "Date used to identify the instrument (YYYYMMDD) and referring to the main event of derivative contract."
  ContractDate: Date
  "Sequence (rank) of expirations based on ContractDate and expiration cycle of product. Used for several validations e.g.: TESProfiles"
  ExpirationIndex: Int
}

"The provided filter for the Expirations entity "
input ExpirationsFilter {
  ProductID: IntFilter
  Product: StringFilter
  MasterContract: StringFilter
  LastTradingDate: DateFilter
  ExpirationDate: DateFilter
  ExpDay: IntFilter
  ExpMonth: IntFilter
  ExpYear: IntFilter
  MonthWeek: IntFilter
  Weekday: StringFilter
  WeekNumber: IntFilter
  DaysToExpiration: IntFilter
  LTDOffset: StringFilter
  ContractDate: DateFilter
  ExpirationIndex: IntFilter
}

"The response type of the Expirations entity "
type ExpirationsResponse {
  "Submission date of the data"
  date: Date
  "list of Expirations items."
  data: [Expirations]
}

"Table provides an overview of all contracts which were created by Eurex customers (flexible contracts) and persist in Eurex system "
type FlexibleContracts {
  "ID of the product."
  ProductID: Int
  "Product symbol."
  Product: String
  "Eurex’s cross-systems numeric, unique, internal ID of the contract."
  ContractID: Int
  "ISIN code related to Eurex’s contracts."
  ISIN: String
  "Eurex's unique business name of the contract. The Contract represents the key fields of a Contract in a string form. It contains the following key Contract attributes which identify a contract uniquely, separated by spaces: Product symbol or Product ID, Contract Type, Contract Date, Settlement Type, Exercise Style, C/P Indicator, Strike Price and Contract Version Number. Key words definition: SI - Standard Instrument (Regular Contract), FI - Flexible Instrument (Flexible Contract), CS - Cash Settlement, PS - Physical Settlement (Non-Cash), EU - European Exercise Style (Options) and AM - American Exercise Style (Options). The content of this field may change in exceptional circumstances. These include among others - Capital Adjustments, which change the contained strike price or changes of the Trading Calendar, which might change the contained contract date."
  Contract: String
  "Indicates the type of security using ISO 10962 standard."
  CFI: String
  "Defines whether contract is a put (P) or call (C)."
  CallPut: String
  "Exercise style of a contract."
  ExerciseStyle: String
  "Contracts strike price."
  Strike: Float
  "Identifies variation of the standard instruments due to corporate action."
  VersionNr: Int
  "Defines the type of settlement for a contract"
  SettlementType: String
  "Contract size of a contract during its lifetime"
  ContractSize: Float
  "Creation date of flexible contract"
  CreationDate: Date
  "Expiry date of the contract."
  ExpirationDate: Date
  "Final settlement price fixing date."
  FinalSettlementDate: Date
  "Date used to identify the instrument (YYYYMMDD) and referring to the main event during lifetime of derivative contract."
  ContractDate: Date
  "Date of last capital adjustment applied to flexible contract"
  CapitalAdjusmentDate: Date
  "Eurex's unique business name of the contract before last capital adjustment"
  PreviousContract: String
  "Contract size of a contract before last capital adjustment"
  PreviousContractSize: Float
  "Product symbol before last capital adjustment."
  PreviousProduct: String
  "Contract strike price before last capital adjustment."
  PreviousStrike: Float
  "Fraction of contract size which is cash settled in case contract is physically settled"
  CashFraction: Float
  "Unadjusted open interest quantity of a contract"
  OpenInterest: Int
  "Settlement day of a contract, referring to a settlement price"
  SettlementDate: Date
  "Settlement price of a contract. Provided in clearing notation for variance futures and total return futures instruments"
  SettlementPrice: Float
  "Flexible to Standard contract conversion date"
  ConversionDate: Date
  "Contract ID of a standard contract which took over the open interest of flexible contract"
  ConvertedToContractID: Int
}

"The provided filter for the FlexibleContracts entity "
input FlexibleContractsFilter {
  ProductID: IntFilter
  Product: StringFilter
  ContractID: IntFilter
  ISIN: StringFilter
  Contract: StringFilter
  CFI: StringFilter
  CallPut: StringFilter
  ExerciseStyle: StringFilter
  Strike: FloatFilter
  VersionNr: IntFilter
  SettlementType: StringFilter
  ContractSize: FloatFilter
  CreationDate: DateFilter
  ExpirationDate: DateFilter
  FinalSettlementDate: DateFilter
  ContractDate: DateFilter
  CapitalAdjusmentDate: DateFilter
  PreviousContract: StringFilter
  PreviousContractSize: FloatFilter
  PreviousProduct: StringFilter
  PreviousStrike: FloatFilter
  CashFraction: FloatFilter
  OpenInterest: IntFilter
  SettlementDate: DateFilter
  SettlementPrice: FloatFilter
  ConversionDate: DateFilter
  ConvertedToContractID: IntFilter
}

"The response type of the FlexibleContracts entity "
type FlexibleContractsResponse {
  "Submission date of the data"
  date: Date
  "list of FlexibleContracts items."
  data: [FlexibleContracts]
}

input FloatFilter {
  ne: Float
  eq: Float
  le: Float
  lt: Float
  ge: Float
  gt: Float
  between: [Float]
}

input FloatFilter1 {
  eq: Float!
}

"Holidays query provides product specific trading holidays for the next 2 years"
type Holidays {
  "ID of the product."
  ProductID: Int
  "Product symbol."
  Product: String
  "This attribute provides a product specific holiday, where no trading takes place"
  Holiday: Date
  "A boolean flag for the separation of product and exchange wide holidays"
  ExchangeHoliday: Int
}

"The provided filter for the Holidays entity "
input HolidaysFilter {
  ProductID: IntFilter
  Product: StringFilter
  Holiday: DateFilter
  ExchangeHoliday: IntFilter
}

"The response type of the Holidays entity "
type HolidaysResponse {
  "Submission date of the data"
  date: Date
  "list of Holidays items."
  data: [Holidays]
}

input IntFilter {
  ne: Int
  eq: Int
  le: Int
  lt: Int
  ge: Int
  gt: Int
  between: [Int]
}

input IntFilter1 {
  eq: Int!
}

"Long type."
scalar Long

input LongFilter {
  ne: Long
  eq: Long
  le: Long
  lt: Long
  ge: Long
  gt: Long
  between: [Long]
}

input LongFilter1 {
  eq: Long!
}

"ProductInfos query provides basic information about products traded on EUREX"
type ProductInfos {
  "ID of the product."
  ProductID: Int
  "Product symbol."
  Product: String
  "Product long name."
  Name: String
  "ISIN assigned to product."
  ProductISIN: String
  "Future or Option discriminator."
  ProductLine: String
  "Product type defined by contract specification."
  ProductType: String
  "Short abbreviation for the product types."
  ProductTypeCode: String
  "Product groupping relevant for transaction size limits (TSL) maintenance"
  TSLProductGroup: String
  "Liquidity class of product, 1 represents the most liquid products."
  LiquidityClass: Int
  "Currency of product."
  Currency: String
  "Price notation indicates whether the price is expressed in monetary value, percentage, yield or as basis points. This attribute also describes how to interpret the quoted price."
  PriceNotation: String
  "Flag to identify whether product may be traded from the USA"
  USapproval: String
  "Supported pre-trade limit type."
  PreTradeLimits: String
  "Settlement type of product."
  SettlementType: String
  "Default contract size."
  ContractSize: Float
  "Minimum price incremental of simple instrument belonging to product."
  TickSize: Float
  "Value of minimum price incremental."
  TickValue: Float
  "Trading partition where product is traded."
  Partition: Int
  "Maximum order quantity."
  MaxOrderQty: Int
  "Attribute provides a maximum order value limit expressed in product currency."
  MaxOrderValue: Long
  "Maximum TES quantity."
  MaxTESQty: Int
  "Maximum future spready quantity."
  MaxFutureSpreadQty: Int
  "Maximum order size for market order."
  MaxMarketOrderQty: Int
  "Maximum price of a product or instrument"
  MaxPrice: Float
  "Maximum position limit."
  PositionLimit: Int
  "This field indicates the static volatility percentage range of the volatility corridor used for static volatility interruptions which would trigger once the execution price on an incoming order would exceed this range compared to the static volatility reference price."
  VolaInterruptStaticPercentage: Float
  "Defines whether market maker protection functionality is supported by product."
  AllowMMP: String
  "Underlying of product."
  Underlying: String
  "Underlying ISIN."
  UnderlyingISIN: String
  "Underlying long name."
  UnderlyingName: String
  "This attribute holds the ISIN of the underlying equity. It should be used when the UnderlyingISIN field contains a placeholder or 'dummy' ISIN"
  EquityISIN: String
  "Underlying category."
  UnderlyingCategory: String
}

"The provided filter for the ProductInfos entity "
input ProductInfosFilter {
  ProductID: IntFilter
  Product: StringFilter
  Name: StringFilter
  ProductISIN: StringFilter
  ProductLine: StringFilter
  ProductType: StringFilter
  ProductTypeCode: StringFilter
  TSLProductGroup: StringFilter
  LiquidityClass: IntFilter
  Currency: StringFilter
  PriceNotation: StringFilter
  USapproval: StringFilter
  PreTradeLimits: StringFilter
  SettlementType: StringFilter
  ContractSize: FloatFilter
  TickSize: FloatFilter
  TickValue: FloatFilter
  Partition: IntFilter
  MaxOrderQty: IntFilter
  MaxOrderValue: LongFilter
  MaxTESQty: IntFilter
  MaxFutureSpreadQty: IntFilter
  MaxMarketOrderQty: IntFilter
  MaxPrice: FloatFilter
  PositionLimit: IntFilter
  VolaInterruptStaticPercentage: FloatFilter
  AllowMMP: StringFilter
  Underlying: StringFilter
  UnderlyingISIN: StringFilter
  UnderlyingName: StringFilter
  EquityISIN: StringFilter
  UnderlyingCategory: StringFilter
}

"The response type of the ProductInfos entity "
type ProductInfosResponse {
  "Submission date of the data"
  date: Date
  "list of ProductInfos items."
  data: [ProductInfos]
}

"List all queries provided by this service"
type Query {
  "Holidays query provides product specific trading holidays for the next 2 years"
  Holidays(filter: HolidaysFilter): HolidaysResponse
  "TradingHours query provides information about on-book and off-book trading hours per product in local Frankfurt time"
  TradingHours(filter: TradingHoursFilter): TradingHoursResponse
  "Expirations query provides expirations information on contract level"
  Expirations(filter: ExpirationsFilter): ExpirationsResponse
  "The table provides a set of settlement prices for standard and flexible contracts listed on Eurex. Information is available for the last 5 trading days"
  SettlementPrices(filter: SettlementPricesFilter!): SettlementPricesResponse
  "VendorCodes query provides vendor specific codes or abbreviations used in the vedor systems for the search or display of Eurex products/contracts"
  VendorCodes(filter: VendorCodesFilter): VendorCodesResponse
  "ProductInfos query provides basic information about products traded on EUREX"
  ProductInfos(filter: ProductInfosFilter): ProductInfosResponse
  "TickRules query provides information about tick rules valid for different traded types and instrument types"
  TickRules(filter: TickRulesFilter): TickRulesResponse
  "Changelog query provides an overview of changes implemented to the API"
  Changelog(filter: ChangelogFilter): ChangelogResponse
  "The table provides essential data on the bonds which meet the criteria of eligibility for the deliverable baskets of Eurex’s Fixed Income Government bond futures. The data provided includes bonds key parameters, such as the expiry date and the coupon rate, as well as their respective conversion factors."
  DeliverableBonds(filter: DeliverableBondsFilter): DeliverableBondsResponse
  "TESProfiles query provides information about TES relevant product configurations"
  TESProfiles(filter: TESProfilesFilter): TESProfilesResponse
  "EnlightResponders query provides list of Enlight responders per product"
  EnlightResponders(filter: EnlightRespondersFilter): EnlightRespondersResponse
  "Table provides an overview of all contracts which were created by Eurex customers (flexible contracts) and persist in Eurex system "
  FlexibleContracts(filter: FlexibleContractsFilter): FlexibleContractsResponse
  "Enlight query provides product configuration for Eurex EnLight service"
  Enlight(filter: EnlightFilter): EnlightResponse
  "Contracts query provides basic information about instruments traded on EUREX"
  Contracts(filter: ContractsFilter!): ContractsResponse
}

"The table provides a set of settlement prices for standard and flexible contracts listed on Eurex. Information is available for the last 5 trading days"
type SettlementPrices {
  "Settlement day of the contract"
  SettlementDate: Date
  "Product symbol."
  Product: String
  "Eurex’s cross-systems numeric unique internal ID of the contract."
  ContractID: Int
  "Settlement price"
  SettlementPrice: Float
  "Settlement price type definition"
  PriceType: String
  "Contract type definition. STANDARD or FLEXIBLE"
  ContractType: String
}

"The provided filter for the SettlementPrices entity "
input SettlementPricesFilter {
  SettlementDate: DateFilter
  Product: StringFilter1!
  ContractID: IntFilter
  SettlementPrice: FloatFilter
  PriceType: StringFilter
  ContractType: StringFilter
}

"The response type of the SettlementPrices entity "
type SettlementPricesResponse {
  "Submission date of the data"
  date: Date
  "list of SettlementPrices items."
  data: [SettlementPrices]
}

input StringFilter {
  ne: String
  eq: String
  le: String
  lt: String
  ge: String
  gt: String
  contains: String
  notContains: String
  beginsWith: String
}

input StringFilter1 {
  eq: String!
}

"TESProfiles query provides information about TES relevant product configurations"
type TESProfiles {
  "ID of the product"
  ProductID: Int
  "Product symbol"
  Product: String
  "Instrument type valid for the corresponding product"
  InstrumentType: String
  "TES type valid for the corresponding product and instrument type"
  TESType: String
  "TES price validation rule which is applied to verify the TES trade when entered to T7."
  PriceValidationRule: String
  "Flag to indicate if auto approval is allowed"
  AllowAutoApproval: String
  "Flag to indicate whether broker trades (i.e. TES trades where the entering participant / firm is involved neither on the buy nor on the sell side) are allowed"
  AllowBroker: String
  "Maximum number of participants involved on the buy and sell side of a TES trade; a value of 2 indicates that only bi-lateral TES trades are allowed (1 buyer and 1 sell) and a value larger than 2 indicates that bi-lateral and multi-lateral TES trades are allowed."
  MaxTrader: Int
  "Minimum number of traded quantity required for a TES trade (primary contracts)."
  MinLotSize: Int
  "Minimum number of traded quantity required for a TES trade (non-primary contracts)."
  MinLotSizeNonPrimary: Int
  "Non-disclosure limit; by default all TES trades are published in real time; in case the quantity of a TES trade is higher than the non-disclosure limit, the entering participant can decide whether the TES trade is not published."
  NonDisclosureLimit: Int
  "Minimum expiry range denotes differentiation of TES profiles based on expiration sequence of contracts. Affected contracts can be retrived in Expirations table"
  MinExpiryRange: Int
  "Defines whether leg price of a complex instrument can be entered by participant or not"
  LegPriceEntry: String
  "The lowes possible price graduation for the price of TES trade"
  TESminStep: Float
}

"The provided filter for the TESProfiles entity "
input TESProfilesFilter {
  ProductID: IntFilter
  Product: StringFilter
  InstrumentType: StringFilter
  TESType: StringFilter
  PriceValidationRule: StringFilter
  AllowAutoApproval: StringFilter
  AllowBroker: StringFilter
  MaxTrader: IntFilter
  MinLotSize: IntFilter
  MinLotSizeNonPrimary: IntFilter
  NonDisclosureLimit: IntFilter
  MinExpiryRange: IntFilter
  LegPriceEntry: StringFilter
  TESminStep: FloatFilter
}

"The response type of the TESProfiles entity "
type TESProfilesResponse {
  "Submission date of the data"
  date: Date
  "list of TESProfiles items."
  data: [TESProfiles]
}

"TickRules query provides information about tick rules valid for different traded types and instrument types"
type TickRules {
  "ID of the product."
  ProductID: Int
  "Product symbol."
  Product: String
  "Trade type for which the tick rule is valid"
  TradeType: String
  "Instrument type for which the tick rule is valid"
  InstrumentType: String
  "Minimum price for the tick rule"
  StartPrice: Float
  "Maximim price for the tick rule"
  EndPrice: Float
  "Price graduation which is valid for prices between start and end price. In case the value is empty, then the tick rule from order book applies"
  PriceStep: Float
}

"The provided filter for the TickRules entity "
input TickRulesFilter {
  ProductID: IntFilter
  Product: StringFilter
  TradeType: StringFilter
  InstrumentType: StringFilter
  StartPrice: FloatFilter
  EndPrice: FloatFilter
  PriceStep: FloatFilter
}

"The response type of the TickRules entity "
type TickRulesResponse {
  "Submission date of the data"
  date: Date
  "list of TickRules items."
  data: [TickRules]
}

"Time in extended ISO 8601 format: HH:mm:ss"
scalar Time

input TimeFilter {
  ne: Time
  eq: Time
  le: Time
  lt: Time
  ge: Time
  gt: Time
  between: [Time]
}

input TimeFilter1 {
  eq: Time!
}

"TradingHours query provides information about on-book and off-book trading hours per product in local Frankfurt time"
type TradingHours {
  "ID of the product"
  ProductID: Int
  "Product symbol"
  Product: String
  """
  Start time of the continuous trading (Format "HH:mm:ss")
  """
  StartContinuousTrading: Time
  """
  End time of the opening auction (Format "HH:mm:ss")
  """
  EndOpeningAuction: Time
  """
  End time of the continuous trading (Format "HH:mm:ss")
  """
  EndContinuousTrading: Time
  """
  End time of the closing auction (Format "HH:mm:ss")
  """
  EndClosingAuction: Time
  "Start time of the trade entry service (TES)"
  StartTES: Time
  "End time of of the trade entry service (TES)"
  EndTES: Time
  """
  Last trading day end time of the continuous trading for the front month contracts (Format "HH:mm:ss")
  """
  LTDBook: Time
  """
  Last trading day end time of the trade entry service (TES) for the front month contracts (Format "HH:mm:ss")
  """
  LTDTES: Time
}

"The provided filter for the TradingHours entity "
input TradingHoursFilter {
  ProductID: IntFilter
  Product: StringFilter
  StartContinuousTrading: TimeFilter
  EndOpeningAuction: TimeFilter
  EndContinuousTrading: TimeFilter
  EndClosingAuction: TimeFilter
  StartTES: TimeFilter
  EndTES: TimeFilter
  LTDBook: TimeFilter
  LTDTES: TimeFilter
}

"The response type of the TradingHours entity "
type TradingHoursResponse {
  "Submission date of the data"
  date: Date
  "list of TradingHours items."
  data: [TradingHours]
}

"VendorCodes query provides vendor specific codes or abbreviations used in the vedor systems for the search or display of Eurex products/contracts"
type VendorCodes {
  "ID of the product."
  ProductID: Int
  "Product symbol."
  Product: String
  "Vendor name. Suffix _UL indicates the underlying code of a vendor"
  Vendor: String
  "Code or abbreviation used in vendor systems"
  Code: String
}

"The provided filter for the VendorCodes entity "
input VendorCodesFilter {
  ProductID: IntFilter
  Product: StringFilter
  Vendor: StringFilter
  Code: StringFilter
}

"The response type of the VendorCodes entity "
type VendorCodesResponse {
  "Submission date of the data"
  date: Date
  "list of VendorCodes items."
  data: [VendorCodes]
}