Messages.h

Go to the documentation of this file.

// Copyright Onix Solutions Limited [OnixS]. All rights reserved.
//
// This software owned by Onix Solutions Limited [OnixS] and is
// protected by copyright law and international copyright treaties.
//
// Access to and use of the software is governed by the terms of the applicable
// OnixS Software Services Agreement (the Agreement) and Customer end user license
// agreements granting a non-assignable, non-transferable and non-exclusive license
// to use the software for it's own data processing purposes under the terms defined
// in the Agreement.
//
// Except as otherwise granted within the terms of the Agreement, copying or
// reproduction of any part of this source code or associated reference material
// to any other location for further reproduction or redistribution, and any
// amendments to this copyright notice, are expressly prohibited.
//
// Any reproduction or redistribution for sale or hiring of the Software not in
// accordance with the terms of the Agreement is a violation of copyright law.
//
 
#pragma once
 
#include <cassert>
#include <stdexcept>
 
#include <OnixS/ICE/BOE/ABI.h>
#include <OnixS/ICE/BOE/messaging/Composites.h>
#include <OnixS/ICE/BOE/messaging/SbeMessage.h>
 
ONIXS_ICEBOE_MESSAGING_NAMESPACE_BEGIN

struct
LogonRequest
: SbeMessage
{
    typedef SchemaTraits Schema;

    typedef LogonRequest ThisType;

    enum { TemplateId = 1 };

    LogonRequest() = default;

    LogonRequest(void* data, EncodedLength length, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        reset();
    }

    LogonRequest(void* data, EncodedLength length, NoFieldsInit, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        resetVariableFields();
    }

    LogonRequest(void* data, EncodedLength length, NoInit)
      : SbeMessage(data, length)
    {
        checkCompatibility();
    }

    explicit
    LogonRequest(const SbeMessage& message)
      : SbeMessage(message)
    {
        assert(message.valid());
 
        checkCompatibility();
    }

    LogonRequest(void* data, EncodedLength length, NoInit, NoCheck) noexcept
      : SbeMessage(data, length, NoCheck())
    {
        assert(schemaId() == Schema::Id);
        assert(version() >= Schema::MinimalVersion);
        assert(TemplateId == templateId());
    }

    ONIXS_ICEBOE_NODISCARD
    auto userId() const noexcept
    {
        constexpr BlockLength offset = 0;
        constexpr BlockLength length = 20;
 
        return fixedStr<length>(offset);
    }

    ThisType& userId(StrRef value) noexcept
    {
        constexpr BlockLength offset = 0;
        constexpr BlockLength length = 20;
 
        setFixedStr<length>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto clientId() const noexcept
    {
        constexpr BlockLength offset = 20;
 
        return ordinary<Int32>(offset);
    }

    ThisType& clientId(Int32 value) noexcept
    {
        constexpr BlockLength offset = 20;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto heartBeatInterval() const noexcept
    {
        constexpr BlockLength offset = 24;
 
        return ordinary<NullUint16NULL>(offset, optional);
    }

    ThisType& heartBeatInterval(Uint16NULL value) noexcept
    {
        constexpr BlockLength offset = 24;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& heartBeatInterval(NullOpt) noexcept
    {
        constexpr BlockLength offset = 24;
 
        setOrdinary(offset, NullUint16NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto applicationName() const noexcept
    {
        constexpr BlockLength offset = 26;
        constexpr BlockLength length = 30;
 
        return fixedStr<length>(offset);
    }

    ThisType& applicationName(StrRef value) noexcept
    {
        constexpr BlockLength offset = 26;
        constexpr BlockLength length = 30;
 
        setFixedStr<length>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto applicationVersion() const noexcept
    {
        constexpr BlockLength offset = 56;
        constexpr BlockLength length = 50;
 
        return fixedStr<length>(offset);
    }

    ThisType& applicationVersion(StrRef value) noexcept
    {
        constexpr BlockLength offset = 56;
        constexpr BlockLength length = 50;
 
        setFixedStr<length>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto applicationVendor() const noexcept
    {
        constexpr BlockLength offset = 106;
        constexpr BlockLength length = 30;
 
        return fixedStr<length>(offset);
    }

    ThisType& applicationVendor(StrRef value) noexcept
    {
        constexpr BlockLength offset = 106;
        constexpr BlockLength length = 30;
 
        setFixedStr<length>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto rawData() const noexcept
    {
        constexpr BlockLength offset = 136;
        constexpr BlockLength length = 50;
 
        return fixedStr<length>(offset);
    }

    ThisType& rawData(StrRef value) noexcept
    {
        constexpr BlockLength offset = 136;
        constexpr BlockLength length = 50;
 
        setFixedStr<length>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto ipSessionToken() const noexcept
    {
        constexpr BlockLength offset = 186;
        constexpr BlockLength length = 50;
 
        return fixedStr<length>(offset, optional);
    }

    ThisType& ipSessionToken(StrRef value) noexcept
    {
        constexpr BlockLength offset = 186;
        constexpr BlockLength length = 50;
 
        setFixedStr<length>(offset, value);
        return *this;
    }
 
    ThisType& ipSessionToken(NullOpt) noexcept
    {
        constexpr BlockLength offset = 186;
        constexpr BlockLength length = 50;
 
        setFixedStr<length>(offset, StrRef());
        return *this;
    }

    constexpr
    static BlockLength minimalBlockLength(ONIXS_ICEBOE_UNUSED SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            236;
    }

    constexpr
    static BlockLength blockLength(SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            minimalBlockLength(version);
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static MessageSize getMinimalVariableFieldsSize(ONIXS_ICEBOE_UNUSED SchemaVersion version)
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            0;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static UInt64 getMaxMessageSize(UInt8) noexcept
    {
        return
            static_cast<UInt64>(MessageHeaderBuilder::Size) +
            blockLength(Schema::Version);
    }

    ThisType& resetVariableFields() noexcept
    {
        return *this;
    }

    ThisType& reset() noexcept
    {
        heartBeatInterval(nullOpt);
        ipSessionToken(nullOpt);
 
        resetVariableFields();
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef className() noexcept
    {
        return constructStrRef("LogonRequest");
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef fixType() noexcept
    {
        return constructStrRef("A");
    }

    ONIXS_ICEBOE_NODISCARD
    std::string toString() const;

    ONIXS_ICEBOE_NODISCARD
    const void* tail() const noexcept
    {
        return
            toOpaquePtr(
                advanceByBytes(
                    binary(),
                    static_cast<ptrdiff_t>(SbeMessage::blockLength()) +
                        MessageHeader::Size));
    }

    ONIXS_ICEBOE_NODISCARD
    EncodedLength calculateBinarySize() const noexcept
    {
        return
            SbeMessage::calculateBinarySize(tail());
    }
 
private:
    void checkLength(
        EncodedLength length, SchemaVersion version) const
    {
       const EncodedLength minimalRequiredLength =
           minimalBlockLength(version) +
           MessageHeader::Size +
           getMinimalVariableFieldsSize(version);
 
       checkBinaryLength(
           *this, length, minimalRequiredLength);
    }
 
    void checkCompatibility() const
    {
        assert(TemplateId == templateId());
 
        checkSchema<Schema>(schemaId(), version());
        checkLength(bufferSize(), version());
    }
};

struct
LogonReport
: SbeMessage
{
    typedef SchemaTraits Schema;

    typedef LogonReport ThisType;

    enum { TemplateId = 101 };

    LogonReport() = default;

    LogonReport(void* data, EncodedLength length, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        reset();
    }

    LogonReport(void* data, EncodedLength length, NoFieldsInit, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        resetVariableFields();
    }

    LogonReport(void* data, EncodedLength length, NoInit)
      : SbeMessage(data, length)
    {
        checkCompatibility();
    }

    explicit
    LogonReport(const SbeMessage& message)
      : SbeMessage(message)
    {
        assert(message.valid());
 
        checkCompatibility();
    }

    LogonReport(void* data, EncodedLength length, NoInit, NoCheck) noexcept
      : SbeMessage(data, length, NoCheck())
    {
        assert(schemaId() == Schema::Id);
        assert(version() >= Schema::MinimalVersion);
        assert(TemplateId == templateId());
    }

    ONIXS_ICEBOE_NODISCARD
    auto userId() const noexcept
    {
        constexpr BlockLength offset = 0;
        constexpr BlockLength length = 20;
 
        return fixedStr<length>(offset);
    }

    ThisType& userId(StrRef value) noexcept
    {
        constexpr BlockLength offset = 0;
        constexpr BlockLength length = 20;
 
        setFixedStr<length>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto heartBeatInterval() const noexcept
    {
        constexpr BlockLength offset = 20;
 
        return ordinary<NullUint16NULL>(offset, optional);
    }

    ThisType& heartBeatInterval(Uint16NULL value) noexcept
    {
        constexpr BlockLength offset = 20;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& heartBeatInterval(NullOpt) noexcept
    {
        constexpr BlockLength offset = 20;
 
        setOrdinary(offset, NullUint16NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto severityLevel() const noexcept
    {
        constexpr BlockLength offset = 22;
 
        return enumeration<SeverityLevelEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& severityLevel(SeverityLevelEnum value) noexcept
    {
        constexpr BlockLength offset = 22;
 
        setEnumeration<SeverityLevelEnum>(offset, value);
        return *this;
    }
 
    ThisType& severityLevel(NullOpt) noexcept
    {
        constexpr BlockLength offset = 22;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto exchangeCode() const noexcept
    {
        constexpr BlockLength offset = 23;
 
        return ordinary<NullInt32NULL>(offset, optional);
    }

    ThisType& exchangeCode(Int32NULL value) noexcept
    {
        constexpr BlockLength offset = 23;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& exchangeCode(NullOpt) noexcept
    {
        constexpr BlockLength offset = 23;
 
        setOrdinary(offset, NullInt32NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto text() const noexcept
    {
        constexpr BlockLength offset = 27;
        constexpr BlockLength length = 100;
 
        return fixedStr<length>(offset, optional);
    }

    ThisType& text(StrRef value) noexcept
    {
        constexpr BlockLength offset = 27;
        constexpr BlockLength length = 100;
 
        setFixedStr<length>(offset, value);
        return *this;
    }
 
    ThisType& text(NullOpt) noexcept
    {
        constexpr BlockLength offset = 27;
        constexpr BlockLength length = 100;
 
        setFixedStr<length>(offset, StrRef());
        return *this;
    }

    constexpr
    static BlockLength minimalBlockLength(ONIXS_ICEBOE_UNUSED SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            127;
    }

    constexpr
    static BlockLength blockLength(SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            minimalBlockLength(version);
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static MessageSize getMinimalVariableFieldsSize(ONIXS_ICEBOE_UNUSED SchemaVersion version)
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            0;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static UInt64 getMaxMessageSize(UInt8) noexcept
    {
        return
            static_cast<UInt64>(MessageHeaderBuilder::Size) +
            blockLength(Schema::Version);
    }

    ThisType& resetVariableFields() noexcept
    {
        return *this;
    }

    ThisType& reset() noexcept
    {
        heartBeatInterval(nullOpt);
        severityLevel(nullOpt);
        exchangeCode(nullOpt);
        text(nullOpt);
 
        resetVariableFields();
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef className() noexcept
    {
        return constructStrRef("LogonReport");
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef fixType() noexcept
    {
        return constructStrRef("LogonReport");
    }

    ONIXS_ICEBOE_NODISCARD
    std::string toString() const;

    ONIXS_ICEBOE_NODISCARD
    const void* tail() const noexcept
    {
        return
            toOpaquePtr(
                advanceByBytes(
                    binary(),
                    static_cast<ptrdiff_t>(SbeMessage::blockLength()) +
                        MessageHeader::Size));
    }

    ONIXS_ICEBOE_NODISCARD
    EncodedLength calculateBinarySize() const noexcept
    {
        return
            SbeMessage::calculateBinarySize(tail());
    }
 
private:
    void checkLength(
        EncodedLength length, SchemaVersion version) const
    {
       const EncodedLength minimalRequiredLength =
           minimalBlockLength(version) +
           MessageHeader::Size +
           getMinimalVariableFieldsSize(version);
 
       checkBinaryLength(
           *this, length, minimalRequiredLength);
    }
 
    void checkCompatibility() const
    {
        assert(TemplateId == templateId());
 
        checkSchema<Schema>(schemaId(), version());
        checkLength(bufferSize(), version());
    }
};

struct
LogoutRequest
: SbeMessage
{
    typedef SchemaTraits Schema;

    typedef LogoutRequest ThisType;

    enum { TemplateId = 13 };

    LogoutRequest() = default;

    LogoutRequest(void* data, EncodedLength length, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        reset();
    }

    LogoutRequest(void* data, EncodedLength length, NoFieldsInit, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        resetVariableFields();
    }

    LogoutRequest(void* data, EncodedLength length, NoInit)
      : SbeMessage(data, length)
    {
        checkCompatibility();
    }

    explicit
    LogoutRequest(const SbeMessage& message)
      : SbeMessage(message)
    {
        assert(message.valid());
 
        checkCompatibility();
    }

    LogoutRequest(void* data, EncodedLength length, NoInit, NoCheck) noexcept
      : SbeMessage(data, length, NoCheck())
    {
        assert(schemaId() == Schema::Id);
        assert(version() >= Schema::MinimalVersion);
        assert(TemplateId == templateId());
    }

    ONIXS_ICEBOE_NODISCARD
    auto userId() const noexcept
    {
        constexpr BlockLength offset = 0;
        constexpr BlockLength length = 20;
 
        return fixedStr<length>(offset);
    }

    ThisType& userId(StrRef value) noexcept
    {
        constexpr BlockLength offset = 0;
        constexpr BlockLength length = 20;
 
        setFixedStr<length>(offset, value);
        return *this;
    }

    constexpr
    static BlockLength minimalBlockLength(ONIXS_ICEBOE_UNUSED SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            20;
    }

    constexpr
    static BlockLength blockLength(SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            minimalBlockLength(version);
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static MessageSize getMinimalVariableFieldsSize(ONIXS_ICEBOE_UNUSED SchemaVersion version)
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            0;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static UInt64 getMaxMessageSize(UInt8) noexcept
    {
        return
            static_cast<UInt64>(MessageHeaderBuilder::Size) +
            blockLength(Schema::Version);
    }

    ThisType& resetVariableFields() noexcept
    {
        return *this;
    }

    ThisType& reset() noexcept
    {
        resetVariableFields();
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef className() noexcept
    {
        return constructStrRef("LogoutRequest");
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef fixType() noexcept
    {
        return constructStrRef("5");
    }

    ONIXS_ICEBOE_NODISCARD
    std::string toString() const;

    ONIXS_ICEBOE_NODISCARD
    const void* tail() const noexcept
    {
        return
            toOpaquePtr(
                advanceByBytes(
                    binary(),
                    static_cast<ptrdiff_t>(SbeMessage::blockLength()) +
                        MessageHeader::Size));
    }

    ONIXS_ICEBOE_NODISCARD
    EncodedLength calculateBinarySize() const noexcept
    {
        return
            SbeMessage::calculateBinarySize(tail());
    }
 
private:
    void checkLength(
        EncodedLength length, SchemaVersion version) const
    {
       const EncodedLength minimalRequiredLength =
           minimalBlockLength(version) +
           MessageHeader::Size +
           getMinimalVariableFieldsSize(version);
 
       checkBinaryLength(
           *this, length, minimalRequiredLength);
    }
 
    void checkCompatibility() const
    {
        assert(TemplateId == templateId());
 
        checkSchema<Schema>(schemaId(), version());
        checkLength(bufferSize(), version());
    }
};

struct
LogoutReport
: SbeMessage
{
    typedef SchemaTraits Schema;

    typedef LogoutReport ThisType;

    enum { TemplateId = 113 };

    LogoutReport() = default;

    LogoutReport(void* data, EncodedLength length, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        reset();
    }

    LogoutReport(void* data, EncodedLength length, NoFieldsInit, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        resetVariableFields();
    }

    LogoutReport(void* data, EncodedLength length, NoInit)
      : SbeMessage(data, length)
    {
        checkCompatibility();
    }

    explicit
    LogoutReport(const SbeMessage& message)
      : SbeMessage(message)
    {
        assert(message.valid());
 
        checkCompatibility();
    }

    LogoutReport(void* data, EncodedLength length, NoInit, NoCheck) noexcept
      : SbeMessage(data, length, NoCheck())
    {
        assert(schemaId() == Schema::Id);
        assert(version() >= Schema::MinimalVersion);
        assert(TemplateId == templateId());
    }

    ONIXS_ICEBOE_NODISCARD
    auto userId() const noexcept
    {
        constexpr BlockLength offset = 0;
        constexpr BlockLength length = 20;
 
        return fixedStr<length>(offset);
    }

    ThisType& userId(StrRef value) noexcept
    {
        constexpr BlockLength offset = 0;
        constexpr BlockLength length = 20;
 
        setFixedStr<length>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto exchangeCode() const noexcept
    {
        constexpr BlockLength offset = 20;
 
        return ordinary<NullInt32NULL>(offset, optional);
    }

    ThisType& exchangeCode(Int32NULL value) noexcept
    {
        constexpr BlockLength offset = 20;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& exchangeCode(NullOpt) noexcept
    {
        constexpr BlockLength offset = 20;
 
        setOrdinary(offset, NullInt32NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto text() const noexcept
    {
        constexpr BlockLength offset = 24;
        constexpr BlockLength length = 100;
 
        return fixedStr<length>(offset, optional);
    }

    ThisType& text(StrRef value) noexcept
    {
        constexpr BlockLength offset = 24;
        constexpr BlockLength length = 100;
 
        setFixedStr<length>(offset, value);
        return *this;
    }
 
    ThisType& text(NullOpt) noexcept
    {
        constexpr BlockLength offset = 24;
        constexpr BlockLength length = 100;
 
        setFixedStr<length>(offset, StrRef());
        return *this;
    }

    constexpr
    static BlockLength minimalBlockLength(ONIXS_ICEBOE_UNUSED SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            124;
    }

    constexpr
    static BlockLength blockLength(SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            minimalBlockLength(version);
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static MessageSize getMinimalVariableFieldsSize(ONIXS_ICEBOE_UNUSED SchemaVersion version)
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            0;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static UInt64 getMaxMessageSize(UInt8) noexcept
    {
        return
            static_cast<UInt64>(MessageHeaderBuilder::Size) +
            blockLength(Schema::Version);
    }

    ThisType& resetVariableFields() noexcept
    {
        return *this;
    }

    ThisType& reset() noexcept
    {
        exchangeCode(nullOpt);
        text(nullOpt);
 
        resetVariableFields();
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef className() noexcept
    {
        return constructStrRef("LogoutReport");
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef fixType() noexcept
    {
        return constructStrRef("5");
    }

    ONIXS_ICEBOE_NODISCARD
    std::string toString() const;

    ONIXS_ICEBOE_NODISCARD
    const void* tail() const noexcept
    {
        return
            toOpaquePtr(
                advanceByBytes(
                    binary(),
                    static_cast<ptrdiff_t>(SbeMessage::blockLength()) +
                        MessageHeader::Size));
    }

    ONIXS_ICEBOE_NODISCARD
    EncodedLength calculateBinarySize() const noexcept
    {
        return
            SbeMessage::calculateBinarySize(tail());
    }
 
private:
    void checkLength(
        EncodedLength length, SchemaVersion version) const
    {
       const EncodedLength minimalRequiredLength =
           minimalBlockLength(version) +
           MessageHeader::Size +
           getMinimalVariableFieldsSize(version);
 
       checkBinaryLength(
           *this, length, minimalRequiredLength);
    }
 
    void checkCompatibility() const
    {
        assert(TemplateId == templateId());
 
        checkSchema<Schema>(schemaId(), version());
        checkLength(bufferSize(), version());
    }
};

struct
HeartBeat
: SbeMessage
{
    typedef SchemaTraits Schema;

    typedef HeartBeat ThisType;

    enum { TemplateId = 51 };

    HeartBeat() = default;

    HeartBeat(void* data, EncodedLength length, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        reset();
    }

    HeartBeat(void* data, EncodedLength length, NoFieldsInit, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        resetVariableFields();
    }

    HeartBeat(void* data, EncodedLength length, NoInit)
      : SbeMessage(data, length)
    {
        checkCompatibility();
    }

    explicit
    HeartBeat(const SbeMessage& message)
      : SbeMessage(message)
    {
        assert(message.valid());
 
        checkCompatibility();
    }

    HeartBeat(void* data, EncodedLength length, NoInit, NoCheck) noexcept
      : SbeMessage(data, length, NoCheck())
    {
        assert(schemaId() == Schema::Id);
        assert(version() >= Schema::MinimalVersion);
        assert(TemplateId == templateId());
    }

    constexpr
    static BlockLength minimalBlockLength(ONIXS_ICEBOE_UNUSED SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            0;
    }

    constexpr
    static BlockLength blockLength(SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            minimalBlockLength(version);
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static MessageSize getMinimalVariableFieldsSize(ONIXS_ICEBOE_UNUSED SchemaVersion version)
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            0;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static UInt64 getMaxMessageSize(UInt8) noexcept
    {
        return
            static_cast<UInt64>(MessageHeaderBuilder::Size) +
            blockLength(Schema::Version);
    }

    ThisType& resetVariableFields() noexcept
    {
        return *this;
    }

    ThisType& reset() noexcept
    {
        resetVariableFields();
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef className() noexcept
    {
        return constructStrRef("HeartBeat");
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef fixType() noexcept
    {
        return constructStrRef("0");
    }

    ONIXS_ICEBOE_NODISCARD
    std::string toString() const;

    ONIXS_ICEBOE_NODISCARD
    const void* tail() const noexcept
    {
        return
            toOpaquePtr(
                advanceByBytes(
                    binary(),
                    static_cast<ptrdiff_t>(SbeMessage::blockLength()) +
                        MessageHeader::Size));
    }

    ONIXS_ICEBOE_NODISCARD
    EncodedLength calculateBinarySize() const noexcept
    {
        return
            SbeMessage::calculateBinarySize(tail());
    }
 
private:
    void checkLength(
        EncodedLength length, SchemaVersion version) const
    {
       const EncodedLength minimalRequiredLength =
           minimalBlockLength(version) +
           MessageHeader::Size +
           getMinimalVariableFieldsSize(version);
 
       checkBinaryLength(
           *this, length, minimalRequiredLength);
    }
 
    void checkCompatibility() const
    {
        assert(TemplateId == templateId());
 
        checkSchema<Schema>(schemaId(), version());
        checkLength(bufferSize(), version());
    }
};

struct
Error
: SbeMessage
{
    typedef SchemaTraits Schema;

    typedef Error ThisType;

    enum { TemplateId = 114 };

    Error() = default;

    Error(void* data, EncodedLength length, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        reset();
    }

    Error(void* data, EncodedLength length, NoFieldsInit, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        resetVariableFields();
    }

    Error(void* data, EncodedLength length, NoInit)
      : SbeMessage(data, length)
    {
        checkCompatibility();
    }

    explicit
    Error(const SbeMessage& message)
      : SbeMessage(message)
    {
        assert(message.valid());
 
        checkCompatibility();
    }

    Error(void* data, EncodedLength length, NoInit, NoCheck) noexcept
      : SbeMessage(data, length, NoCheck())
    {
        assert(schemaId() == Schema::Id);
        assert(version() >= Schema::MinimalVersion);
        assert(TemplateId == templateId());
    }

    ONIXS_ICEBOE_NODISCARD
    auto refSequenceId() const noexcept
    {
        constexpr BlockLength offset = 0;
 
        return ordinary<UInt32>(offset);
    }

    ThisType& refSequenceId(UInt32 value) noexcept
    {
        constexpr BlockLength offset = 0;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto severityLevel() const noexcept
    {
        constexpr BlockLength offset = 4;
 
        return enumeration<SeverityLevelEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& severityLevel(SeverityLevelEnum value) noexcept
    {
        constexpr BlockLength offset = 4;
 
        setEnumeration<SeverityLevelEnum>(offset, value);
        return *this;
    }
 
    ThisType& severityLevel(NullOpt) noexcept
    {
        constexpr BlockLength offset = 4;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto supportedSchemaVersion() const noexcept
    {
        constexpr BlockLength offset = 5;
        constexpr BlockLength length = 20;
 
        return fixedStr<length>(offset);
    }

    ThisType& supportedSchemaVersion(StrRef value) noexcept
    {
        constexpr BlockLength offset = 5;
        constexpr BlockLength length = 20;
 
        setFixedStr<length>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto exchangeCode() const noexcept
    {
        constexpr BlockLength offset = 25;
 
        return ordinary<NullInt32NULL>(offset, optional);
    }

    ThisType& exchangeCode(Int32NULL value) noexcept
    {
        constexpr BlockLength offset = 25;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& exchangeCode(NullOpt) noexcept
    {
        constexpr BlockLength offset = 25;
 
        setOrdinary(offset, NullInt32NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto text() const noexcept
    {
        constexpr BlockLength offset = 29;
        constexpr BlockLength length = 100;
 
        return fixedStr<length>(offset, optional);
    }

    ThisType& text(StrRef value) noexcept
    {
        constexpr BlockLength offset = 29;
        constexpr BlockLength length = 100;
 
        setFixedStr<length>(offset, value);
        return *this;
    }
 
    ThisType& text(NullOpt) noexcept
    {
        constexpr BlockLength offset = 29;
        constexpr BlockLength length = 100;
 
        setFixedStr<length>(offset, StrRef());
        return *this;
    }

    constexpr
    static BlockLength minimalBlockLength(ONIXS_ICEBOE_UNUSED SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            129;
    }

    constexpr
    static BlockLength blockLength(SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            minimalBlockLength(version);
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static MessageSize getMinimalVariableFieldsSize(ONIXS_ICEBOE_UNUSED SchemaVersion version)
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            0;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static UInt64 getMaxMessageSize(UInt8) noexcept
    {
        return
            static_cast<UInt64>(MessageHeaderBuilder::Size) +
            blockLength(Schema::Version);
    }

    ThisType& resetVariableFields() noexcept
    {
        return *this;
    }

    ThisType& reset() noexcept
    {
        severityLevel(nullOpt);
        exchangeCode(nullOpt);
        text(nullOpt);
 
        resetVariableFields();
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef className() noexcept
    {
        return constructStrRef("Error");
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef fixType() noexcept
    {
        return constructStrRef("Error");
    }

    ONIXS_ICEBOE_NODISCARD
    std::string toString() const;

    ONIXS_ICEBOE_NODISCARD
    const void* tail() const noexcept
    {
        return
            toOpaquePtr(
                advanceByBytes(
                    binary(),
                    static_cast<ptrdiff_t>(SbeMessage::blockLength()) +
                        MessageHeader::Size));
    }

    ONIXS_ICEBOE_NODISCARD
    EncodedLength calculateBinarySize() const noexcept
    {
        return
            SbeMessage::calculateBinarySize(tail());
    }
 
private:
    void checkLength(
        EncodedLength length, SchemaVersion version) const
    {
       const EncodedLength minimalRequiredLength =
           minimalBlockLength(version) +
           MessageHeader::Size +
           getMinimalVariableFieldsSize(version);
 
       checkBinaryLength(
           *this, length, minimalRequiredLength);
    }
 
    void checkCompatibility() const
    {
        assert(TemplateId == templateId());
 
        checkSchema<Schema>(schemaId(), version());
        checkLength(bufferSize(), version());
    }
};

struct
News
: SbeMessage
{
    typedef SchemaTraits Schema;

    typedef News ThisType;

    enum { TemplateId = 116 };

    News() = default;

    News(void* data, EncodedLength length, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        reset();
    }

    News(void* data, EncodedLength length, NoFieldsInit, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        resetVariableFields();
    }

    News(void* data, EncodedLength length, NoInit)
      : SbeMessage(data, length)
    {
        checkCompatibility();
    }

    explicit
    News(const SbeMessage& message)
      : SbeMessage(message)
    {
        assert(message.valid());
 
        checkCompatibility();
    }

    News(void* data, EncodedLength length, NoInit, NoCheck) noexcept
      : SbeMessage(data, length, NoCheck())
    {
        assert(schemaId() == Schema::Id);
        assert(version() >= Schema::MinimalVersion);
        assert(TemplateId == templateId());
    }

    ONIXS_ICEBOE_NODISCARD
    auto userId() const noexcept
    {
        constexpr BlockLength offset = 0;
        constexpr BlockLength length = 20;
 
        return fixedStr<length>(offset);
    }

    ThisType& userId(StrRef value) noexcept
    {
        constexpr BlockLength offset = 0;
        constexpr BlockLength length = 20;
 
        setFixedStr<length>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto exchangeCode() const noexcept
    {
        constexpr BlockLength offset = 20;
 
        return ordinary<NullInt32NULL>(offset, optional);
    }

    ThisType& exchangeCode(Int32NULL value) noexcept
    {
        constexpr BlockLength offset = 20;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& exchangeCode(NullOpt) noexcept
    {
        constexpr BlockLength offset = 20;
 
        setOrdinary(offset, NullInt32NULL());
        return *this;
    }
 
    ONIXS_ICEBOE_NODISCARD
    StrRef text() const noexcept
    {
        return getVariableLengthField(textAccess(), *this);
    }
 
    ThisType& text(StrRef value)
    {
        setVariableLengthField(
            textAccess(),
            value,
            *this);
 
        return *this;
    }

    constexpr
    static BlockLength minimalBlockLength(ONIXS_ICEBOE_UNUSED SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            24;
    }

    constexpr
    static BlockLength blockLength(SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            minimalBlockLength(version);
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static MessageSize getMinimalVariableFieldsSize(ONIXS_ICEBOE_UNUSED SchemaVersion version)
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            static_cast<MessageSize>(VarString16::Size);
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static UInt64 getMaxMessageSize(UInt8) noexcept
    {
        return
            SbeMessage::getMaxMessageSize();
    }

    ThisType& resetVariableFields() noexcept
    {
        text(nullOpt);
        return *this;
    }

    ThisType& reset() noexcept
    {
        exchangeCode(nullOpt);
 
        resetVariableFields();
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef className() noexcept
    {
        return constructStrRef("News");
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef fixType() noexcept
    {
        return constructStrRef("News");
    }

    ONIXS_ICEBOE_NODISCARD
    std::string toString() const;

    ONIXS_ICEBOE_NODISCARD
    const void* tail() const noexcept
    {
        return
            toOpaquePtr(
                (text().end()));
    }

    ONIXS_ICEBOE_NODISCARD
    EncodedLength calculateBinarySize() const noexcept
    {
        return
            SbeMessage::calculateBinarySize(tail());
    }
 
private:
    void checkLength(
        EncodedLength length, SchemaVersion version) const
    {
       const EncodedLength minimalRequiredLength =
           minimalBlockLength(version) +
           MessageHeader::Size +
           getMinimalVariableFieldsSize(version);
 
       checkBinaryLength(
           *this, length, minimalRequiredLength);
    }

    void checkVarLenFields() const
    {
        variableLengthFields().
            checkTail<VarString16>();
    }
 
    void checkCompatibility() const
    {
        assert(TemplateId == templateId());
 
        checkSchema<Schema>(schemaId(), version());
        checkLength(bufferSize(), version());
        checkVarLenFields();
    }

    struct textAccess
    {
        VarString16& operator()(const News& obj) const noexcept
        {
            return obj.
                variableLengthFields().
                    head<VarString16>();
        }
    };

    ThisType& text(NullOpt) noexcept
    {
        setVariableLengthFieldToNull(textAccess(), *this);
 
        return *this;
    }
};

struct
SecurityDefinitionReport_Strategy
: SbeMessage
{
    typedef SchemaTraits Schema;

    typedef SecurityDefinitionReport_Strategy ThisType;

    enum { TemplateId = 112 };

    struct
    BlockDetailsEntry : SbeGroupEntry
    <
        GroupSizeEncoding::BlockLength
    >
    {
        typedef
        SbeGroupEntry
        <
            GroupSizeEncoding::BlockLength
        >
        Base;

        typedef BlockDetailsEntry ThisType;

        BlockDetailsEntry(void* data, EncodedLength length, SchemaVersion version)
          : Base(data, numericCast<Base::BlockLength>(length), version)
        {
            assert(version >= Schema::MinimalVersion);
            assert(length >= minimalBlockLength(version));
        }

        ThisType& resetVariableFields() noexcept
        {
            return *this;
        }

        ThisType& reset() noexcept
        {
            blockDetailsTradeType(nullOpt);
 
            resetVariableFields();
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto blockDetailsBlockType() const noexcept
        {
            constexpr BlockLength offset = 0;
 
            return enumeration<BlockTypeEnum>(offset);
        }

        ThisType& blockDetailsBlockType(BlockTypeEnum value) noexcept
        {
            constexpr BlockLength offset = 0;
 
            setEnumeration<BlockTypeEnum>(offset, value);
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto blockDetailsTradeType() const noexcept
        {
            constexpr BlockLength offset = 1;
            constexpr BlockLength length = 3;
 
            return fixedStr<length>(offset, optional);
        }

        ThisType& blockDetailsTradeType(StrRef value) noexcept
        {
            constexpr BlockLength offset = 1;
            constexpr BlockLength length = 3;
 
            setFixedStr<length>(offset, value);
            return *this;
        }
 
        ThisType& blockDetailsTradeType(NullOpt) noexcept
        {
            constexpr BlockLength offset = 1;
            constexpr BlockLength length = 3;
 
            setFixedStr<length>(offset, StrRef());
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto blockDetailsMinQty() const noexcept
        {
            constexpr BlockLength offset = 4;
 
            return ordinary<Decimal9>(offset);
        }

        ThisType& blockDetailsMinQty(Decimal9 value) noexcept
        {
            constexpr BlockLength offset = 4;
 
            setOrdinary(offset, value);
            return *this;
        }

        constexpr
        static BlockLength blockLength(SchemaVersion version) noexcept
        {
            return
                ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
                minimalBlockLength(version);
        }

        constexpr
        static BlockLength minimalBlockLength(ONIXS_ICEBOE_UNUSED SchemaVersion version) noexcept
        {
            return
                ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
                12;
        }

        ONIXS_ICEBOE_NODISCARD
        constexpr
        static StrRef className() noexcept
        {
            return constructStrRef("SecurityDefinitionReport_Strategy.BlockDetailsEntry");
        }
    };

    typedef
    SbeGroup<BlockDetailsEntry, GroupSizeEncoding, MessageSize>
    BlockDetails;

    struct
    SecurityAltIDEntry : SbeGroupEntry
    <
        GroupSizeEncoding::BlockLength
    >
    {
        typedef
        SbeGroupEntry
        <
            GroupSizeEncoding::BlockLength
        >
        Base;

        typedef SecurityAltIDEntry ThisType;

        SecurityAltIDEntry(void* data, EncodedLength length, SchemaVersion version)
          : Base(data, numericCast<Base::BlockLength>(length), version)
        {
            assert(version >= Schema::MinimalVersion);
            assert(length >= minimalBlockLength(version));
        }

        ThisType& resetVariableFields() noexcept
        {
            return *this;
        }

        ThisType& reset() noexcept
        {
            securityAltId(nullOpt);
            securityAltIdSource(nullOpt);
 
            resetVariableFields();
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto securityAltId() const noexcept
        {
            constexpr BlockLength offset = 0;
            constexpr BlockLength length = 30;
 
            return fixedStr<length>(offset, optional);
        }

        ThisType& securityAltId(StrRef value) noexcept
        {
            constexpr BlockLength offset = 0;
            constexpr BlockLength length = 30;
 
            setFixedStr<length>(offset, value);
            return *this;
        }
 
        ThisType& securityAltId(NullOpt) noexcept
        {
            constexpr BlockLength offset = 0;
            constexpr BlockLength length = 30;
 
            setFixedStr<length>(offset, StrRef());
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto securityAltIdSource() const noexcept
        {
            constexpr BlockLength offset = 30;
            constexpr BlockLength length = 3;
 
            return fixedStr<length>(offset, optional);
        }

        ThisType& securityAltIdSource(StrRef value) noexcept
        {
            constexpr BlockLength offset = 30;
            constexpr BlockLength length = 3;
 
            setFixedStr<length>(offset, value);
            return *this;
        }
 
        ThisType& securityAltIdSource(NullOpt) noexcept
        {
            constexpr BlockLength offset = 30;
            constexpr BlockLength length = 3;
 
            setFixedStr<length>(offset, StrRef());
            return *this;
        }

        constexpr
        static BlockLength blockLength(SchemaVersion version) noexcept
        {
            return
                ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
                minimalBlockLength(version);
        }

        constexpr
        static BlockLength minimalBlockLength(ONIXS_ICEBOE_UNUSED SchemaVersion version) noexcept
        {
            return
                ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
                33;
        }

        ONIXS_ICEBOE_NODISCARD
        constexpr
        static StrRef className() noexcept
        {
            return constructStrRef("SecurityDefinitionReport_Strategy.SecurityAltIDEntry");
        }
    };

    typedef
    SbeGroup<SecurityAltIDEntry, GroupSizeEncoding, MessageSize>
    SecurityAltID;

    struct
    LegsEntry : SbeGroupEntry
    <
        GroupSizeEncoding::BlockLength
    >
    {
        typedef
        SbeGroupEntry
        <
            GroupSizeEncoding::BlockLength
        >
        Base;

        typedef LegsEntry ThisType;

        LegsEntry(void* data, EncodedLength length, SchemaVersion version)
          : Base(data, numericCast<Base::BlockLength>(length), version)
        {
            assert(version >= Schema::MinimalVersion);
            assert(length >= minimalBlockLength(version));
        }

        ThisType& resetVariableFields() noexcept
        {
            return *this;
        }

        ThisType& reset() noexcept
        {
            legSecuritySubType(nullOpt);
            legPrice(nullOpt);
            legOptionDelta(nullOpt);
 
            resetVariableFields();
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto legSymbol() const noexcept
        {
            constexpr BlockLength offset = 0;
 
            return ordinary<Int32>(offset);
        }

        ThisType& legSymbol(Int32 value) noexcept
        {
            constexpr BlockLength offset = 0;
 
            setOrdinary(offset, value);
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto legSecurityType() const noexcept
        {
            constexpr BlockLength offset = 4;
 
            return enumeration<SecurityTypeEnum>(offset);
        }

        ThisType& legSecurityType(SecurityTypeEnum value) noexcept
        {
            constexpr BlockLength offset = 4;
 
            setEnumeration<SecurityTypeEnum>(offset, value);
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto legSecuritySubType() const noexcept
        {
            constexpr BlockLength offset = 5;
 
            return ordinary<NullInt16NULL>(offset, optional);
        }

        ThisType& legSecuritySubType(Int16NULL value) noexcept
        {
            constexpr BlockLength offset = 5;
 
            setOrdinary(offset, value);
            return *this;
        }
 
        ThisType& legSecuritySubType(NullOpt) noexcept
        {
            constexpr BlockLength offset = 5;
 
            setOrdinary(offset, NullInt16NULL());
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto legSide() const noexcept
        {
            constexpr BlockLength offset = 7;
 
            return enumeration<SideEnum>(offset);
        }

        ThisType& legSide(SideEnum value) noexcept
        {
            constexpr BlockLength offset = 7;
 
            setEnumeration<SideEnum>(offset, value);
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto legPrice() const noexcept
        {
            constexpr BlockLength offset = 8;
 
            return ordinary<NullDecimal9>(offset, optional);
        }

        ThisType& legPrice(Decimal9 value) noexcept
        {
            constexpr BlockLength offset = 8;
 
            setOrdinary(offset, value);
            return *this;
        }
 
        ThisType& legPrice(NullOpt) noexcept
        {
            constexpr BlockLength offset = 8;
 
            setOrdinary(offset, NullDecimal9());
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto legOptionDelta() const noexcept
        {
            constexpr BlockLength offset = 16;
 
            return ordinary<NullInt32NULL>(offset, optional);
        }

        ThisType& legOptionDelta(Int32NULL value) noexcept
        {
            constexpr BlockLength offset = 16;
 
            setOrdinary(offset, value);
            return *this;
        }
 
        ThisType& legOptionDelta(NullOpt) noexcept
        {
            constexpr BlockLength offset = 16;
 
            setOrdinary(offset, NullInt32NULL());
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto legRatioQtyDenominator() const noexcept
        {
            constexpr BlockLength offset = 20;
 
            return ordinary<Int16>(offset);
        }

        ThisType& legRatioQtyDenominator(Int16 value) noexcept
        {
            constexpr BlockLength offset = 20;
 
            setOrdinary(offset, value);
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto legRatioQtyNumerator() const noexcept
        {
            constexpr BlockLength offset = 22;
 
            return ordinary<Int16>(offset);
        }

        ThisType& legRatioQtyNumerator(Int16 value) noexcept
        {
            constexpr BlockLength offset = 22;
 
            setOrdinary(offset, value);
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto legRatioPriceDenominator() const noexcept
        {
            constexpr BlockLength offset = 24;
 
            return ordinary<Int16>(offset);
        }

        ThisType& legRatioPriceDenominator(Int16 value) noexcept
        {
            constexpr BlockLength offset = 24;
 
            setOrdinary(offset, value);
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto legRatioPriceNumerator() const noexcept
        {
            constexpr BlockLength offset = 26;
 
            return ordinary<Int16>(offset);
        }

        ThisType& legRatioPriceNumerator(Int16 value) noexcept
        {
            constexpr BlockLength offset = 26;
 
            setOrdinary(offset, value);
            return *this;
        }

        constexpr
        static BlockLength blockLength(SchemaVersion version) noexcept
        {
            return
                ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
                minimalBlockLength(version);
        }

        constexpr
        static BlockLength minimalBlockLength(ONIXS_ICEBOE_UNUSED SchemaVersion version) noexcept
        {
            return
                ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
                28;
        }

        ONIXS_ICEBOE_NODISCARD
        constexpr
        static StrRef className() noexcept
        {
            return constructStrRef("SecurityDefinitionReport_Strategy.LegsEntry");
        }
    };

    typedef
    SbeGroup<LegsEntry, GroupSizeEncoding, MessageSize>
    Legs;

    SecurityDefinitionReport_Strategy() = default;

    SecurityDefinitionReport_Strategy(void* data, EncodedLength length, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        reset();
    }

    SecurityDefinitionReport_Strategy(void* data, EncodedLength length, NoFieldsInit, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        resetVariableFields();
    }

    SecurityDefinitionReport_Strategy(void* data, EncodedLength length, NoInit)
      : SbeMessage(data, length)
    {
        checkCompatibility();
    }

    explicit
    SecurityDefinitionReport_Strategy(const SbeMessage& message)
      : SbeMessage(message)
    {
        assert(message.valid());
 
        checkCompatibility();
    }

    SecurityDefinitionReport_Strategy(void* data, EncodedLength length, NoInit, NoCheck) noexcept
      : SbeMessage(data, length, NoCheck())
    {
        assert(schemaId() == Schema::Id);
        assert(version() >= Schema::MinimalVersion);
        assert(TemplateId == templateId());
    }

    ONIXS_ICEBOE_NODISCARD
    auto securityReqId() const noexcept
    {
        constexpr BlockLength offset = 0;
 
        return ordinary<Int32>(offset);
    }

    ThisType& securityReqId(Int32 value) noexcept
    {
        constexpr BlockLength offset = 0;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto securityResponseType() const noexcept
    {
        constexpr BlockLength offset = 4;
 
        return enumeration<SecurityResponseTypeEnum>(offset);
    }

    ThisType& securityResponseType(SecurityResponseTypeEnum value) noexcept
    {
        constexpr BlockLength offset = 4;
 
        setEnumeration<SecurityResponseTypeEnum>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto securityResponseId() const noexcept
    {
        constexpr BlockLength offset = 5;
 
        return ordinary<Int32>(offset);
    }

    ThisType& securityResponseId(Int32 value) noexcept
    {
        constexpr BlockLength offset = 5;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto marketTypeId() const noexcept
    {
        constexpr BlockLength offset = 9;
 
        return ordinary<Int32>(offset);
    }

    ThisType& marketTypeId(Int32 value) noexcept
    {
        constexpr BlockLength offset = 9;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto rpts() const noexcept
    {
        constexpr BlockLength offset = 13;
 
        return ordinary<Int32>(offset);
    }

    ThisType& rpts(Int32 value) noexcept
    {
        constexpr BlockLength offset = 13;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto listSeqNo() const noexcept
    {
        constexpr BlockLength offset = 17;
 
        return ordinary<Int32>(offset);
    }

    ThisType& listSeqNo(Int32 value) noexcept
    {
        constexpr BlockLength offset = 17;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto symbol() const noexcept
    {
        constexpr BlockLength offset = 21;
 
        return ordinary<Int32>(offset);
    }

    ThisType& symbol(Int32 value) noexcept
    {
        constexpr BlockLength offset = 21;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto underlyingStrategySymbol() const noexcept
    {
        constexpr BlockLength offset = 25;
 
        return ordinary<Int32>(offset);
    }

    ThisType& underlyingStrategySymbol(Int32 value) noexcept
    {
        constexpr BlockLength offset = 25;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto maturityDate() const noexcept(dateToTimestamp::Nothrow)
    {
        constexpr BlockLength offset = 29;
        return convertible<NullUTCDateOnly, dateToTimestamp>(offset, optional);
    }

    ThisType& maturityDate(Timestamp value) noexcept(timestampToDate::Nothrow)
    {
        constexpr BlockLength offset = 29;
 
        setOrdinary(offset, convert<timestampToDate>(value));
        return *this;
    }
 
    ThisType& maturityDate(NullOpt) noexcept
    {
        constexpr BlockLength offset = 29;
 
        setOrdinary(offset, NullUTCDateOnly());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto securityTradingStatus() const noexcept
    {
        constexpr BlockLength offset = 31;
 
        return enumeration<SecurityTradingStatusEnum>(offset);
    }

    ThisType& securityTradingStatus(SecurityTradingStatusEnum value) noexcept
    {
        constexpr BlockLength offset = 31;
 
        setEnumeration<SecurityTradingStatusEnum>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto securitySubType() const noexcept
    {
        constexpr BlockLength offset = 32;
 
        return ordinary<Int16>(offset);
    }

    ThisType& securitySubType(Int16 value) noexcept
    {
        constexpr BlockLength offset = 32;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto exchangeSilo() const noexcept
    {
        constexpr BlockLength offset = 34;
 
        return enumeration<ExchangeSiloEnum>(offset);
    }

    ThisType& exchangeSilo(ExchangeSiloEnum value) noexcept
    {
        constexpr BlockLength offset = 34;
 
        setEnumeration<ExchangeSiloEnum>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto transactTime() const noexcept(ticksToTimestamp::Nothrow)
    {
        constexpr BlockLength offset = 35;
        return convertible<ticksToTimestamp>(offset);
    }

    ThisType& transactTime(Timestamp value) noexcept(timestampToTicks::Nothrow)
    {
        constexpr BlockLength offset = 35;
 
        setOrdinary(offset, convert<timestampToTicks>(value));
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto legDealsSuppressed() const noexcept
    {
        constexpr BlockLength offset = 43;
 
        return enumeration<BooleanEnum>(offset);
    }

    ThisType& legDealsSuppressed(BooleanEnum value) noexcept
    {
        constexpr BlockLength offset = 43;
 
        setEnumeration<BooleanEnum>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto incrementPrice() const noexcept
    {
        constexpr BlockLength offset = 44;
 
        return ordinary<Decimal9>(offset);
    }

    ThisType& incrementPrice(Decimal9 value) noexcept
    {
        constexpr BlockLength offset = 44;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto incrementQty() const noexcept
    {
        constexpr BlockLength offset = 52;
 
        return ordinary<Decimal9>(offset);
    }

    ThisType& incrementQty(Decimal9 value) noexcept
    {
        constexpr BlockLength offset = 52;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto minPrice() const noexcept
    {
        constexpr BlockLength offset = 60;
 
        return ordinary<Decimal9>(offset);
    }

    ThisType& minPrice(Decimal9 value) noexcept
    {
        constexpr BlockLength offset = 60;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto maxPrice() const noexcept
    {
        constexpr BlockLength offset = 68;
 
        return ordinary<Decimal9>(offset);
    }

    ThisType& maxPrice(Decimal9 value) noexcept
    {
        constexpr BlockLength offset = 68;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto numOfDecimalPrice() const noexcept
    {
        constexpr BlockLength offset = 76;
 
        return ordinary<Int8>(offset);
    }

    ThisType& numOfDecimalPrice(Int8 value) noexcept
    {
        constexpr BlockLength offset = 76;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto numOfDecimalQty() const noexcept
    {
        constexpr BlockLength offset = 77;
 
        return ordinary<Int8>(offset);
    }

    ThisType& numOfDecimalQty(Int8 value) noexcept
    {
        constexpr BlockLength offset = 77;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto productId() const noexcept
    {
        constexpr BlockLength offset = 78;
 
        return ordinary<Int32>(offset);
    }

    ThisType& productId(Int32 value) noexcept
    {
        constexpr BlockLength offset = 78;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto baseNumLots() const noexcept
    {
        constexpr BlockLength offset = 82;
 
        return ordinary<NullInt32NULL>(offset, optional);
    }

    ThisType& baseNumLots(Int32NULL value) noexcept
    {
        constexpr BlockLength offset = 82;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& baseNumLots(NullOpt) noexcept
    {
        constexpr BlockLength offset = 82;
 
        setOrdinary(offset, NullInt32NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto denominator() const noexcept
    {
        constexpr BlockLength offset = 86;
 
        return ordinary<Int32>(offset);
    }

    ThisType& denominator(Int32 value) noexcept
    {
        constexpr BlockLength offset = 86;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto impliedType() const noexcept
    {
        constexpr BlockLength offset = 90;
 
        return ordinary<NullCharType>(offset, optional);
    }

    ThisType& impliedType(CharType value) noexcept
    {
        constexpr BlockLength offset = 90;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& impliedType(NullOpt) noexcept
    {
        constexpr BlockLength offset = 90;
 
        setOrdinary(offset, NullCharType());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto offExchangeIncrementPrice() const noexcept
    {
        constexpr BlockLength offset = 91;
 
        return ordinary<NullDecimal9>(offset, optional);
    }

    ThisType& offExchangeIncrementPrice(Decimal9 value) noexcept
    {
        constexpr BlockLength offset = 91;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& offExchangeIncrementPrice(NullOpt) noexcept
    {
        constexpr BlockLength offset = 91;
 
        setOrdinary(offset, NullDecimal9());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto offExchangeIncrementQty() const noexcept
    {
        constexpr BlockLength offset = 99;
 
        return ordinary<NullDecimal9>(offset, optional);
    }

    ThisType& offExchangeIncrementQty(Decimal9 value) noexcept
    {
        constexpr BlockLength offset = 99;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& offExchangeIncrementQty(NullOpt) noexcept
    {
        constexpr BlockLength offset = 99;
 
        setOrdinary(offset, NullDecimal9());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto numOfDecimalStrikePrice() const noexcept
    {
        constexpr BlockLength offset = 107;
 
        return ordinary<NullInt8NULL>(offset, optional);
    }

    ThisType& numOfDecimalStrikePrice(Int8NULL value) noexcept
    {
        constexpr BlockLength offset = 107;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& numOfDecimalStrikePrice(NullOpt) noexcept
    {
        constexpr BlockLength offset = 107;
 
        setOrdinary(offset, NullInt8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto numOfCycles() const noexcept
    {
        constexpr BlockLength offset = 108;
 
        return ordinary<NullInt16NULL>(offset, optional);
    }

    ThisType& numOfCycles(Int16NULL value) noexcept
    {
        constexpr BlockLength offset = 108;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& numOfCycles(NullOpt) noexcept
    {
        constexpr BlockLength offset = 108;
 
        setOrdinary(offset, NullInt16NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto lotSizeMultiplier() const noexcept
    {
        constexpr BlockLength offset = 110;
 
        return ordinary<NullDecimal9>(offset, optional);
    }

    ThisType& lotSizeMultiplier(Decimal9 value) noexcept
    {
        constexpr BlockLength offset = 110;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& lotSizeMultiplier(NullOpt) noexcept
    {
        constexpr BlockLength offset = 110;
 
        setOrdinary(offset, NullDecimal9());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto blockOnly() const noexcept
    {
        constexpr BlockLength offset = 118;
 
        return enumeration<BooleanEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& blockOnly(BooleanEnum value) noexcept
    {
        constexpr BlockLength offset = 118;
 
        setEnumeration<BooleanEnum>(offset, value);
        return *this;
    }
 
    ThisType& blockOnly(NullOpt) noexcept
    {
        constexpr BlockLength offset = 118;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto flexAllowed() const noexcept
    {
        constexpr BlockLength offset = 119;
 
        return enumeration<BooleanEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& flexAllowed(BooleanEnum value) noexcept
    {
        constexpr BlockLength offset = 119;
 
        setEnumeration<BooleanEnum>(offset, value);
        return *this;
    }
 
    ThisType& flexAllowed(NullOpt) noexcept
    {
        constexpr BlockLength offset = 119;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto gtAllowed() const noexcept
    {
        constexpr BlockLength offset = 120;
 
        return enumeration<BooleanEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& gtAllowed(BooleanEnum value) noexcept
    {
        constexpr BlockLength offset = 120;
 
        setEnumeration<BooleanEnum>(offset, value);
        return *this;
    }
 
    ThisType& gtAllowed(NullOpt) noexcept
    {
        constexpr BlockLength offset = 120;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto mifidRegulatedMarket() const noexcept
    {
        constexpr BlockLength offset = 121;
 
        return enumeration<BooleanEnum>(offset);
    }

    ThisType& mifidRegulatedMarket(BooleanEnum value) noexcept
    {
        constexpr BlockLength offset = 121;
 
        setEnumeration<BooleanEnum>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto stripType() const noexcept
    {
        constexpr BlockLength offset = 122;
 
        return ordinary<Int16>(offset);
    }

    ThisType& stripType(Int16 value) noexcept
    {
        constexpr BlockLength offset = 122;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto hubId() const noexcept
    {
        constexpr BlockLength offset = 124;
 
        return ordinary<Int32>(offset);
    }

    ThisType& hubId(Int32 value) noexcept
    {
        constexpr BlockLength offset = 124;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto overrideBlockMin() const noexcept
    {
        constexpr BlockLength offset = 128;
 
        return enumeration<BooleanEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& overrideBlockMin(BooleanEnum value) noexcept
    {
        constexpr BlockLength offset = 128;
 
        setEnumeration<BooleanEnum>(offset, value);
        return *this;
    }
 
    ThisType& overrideBlockMin(NullOpt) noexcept
    {
        constexpr BlockLength offset = 128;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto testMarketIndicator() const noexcept
    {
        constexpr BlockLength offset = 129;
 
        return enumeration<BooleanEnum>(offset);
    }

    ThisType& testMarketIndicator(BooleanEnum value) noexcept
    {
        constexpr BlockLength offset = 129;
 
        setEnumeration<BooleanEnum>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto screenTickValue() const noexcept
    {
        constexpr BlockLength offset = 130;
 
        return ordinary<Decimal9>(offset);
    }

    ThisType& screenTickValue(Decimal9 value) noexcept
    {
        constexpr BlockLength offset = 130;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto blockTickValue() const noexcept
    {
        constexpr BlockLength offset = 138;
 
        return ordinary<Decimal9>(offset);
    }

    ThisType& blockTickValue(Decimal9 value) noexcept
    {
        constexpr BlockLength offset = 138;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    BlockDetails blockDetails() const noexcept
    {
        return getGroup<BlockDetails>(
            BlockDetailsAccess(),
            *this);
    }

    ONIXS_ICEBOE_NODISCARD
    BlockDetails blockDetails() noexcept
    {
        return getGroup<BlockDetails>(
            BlockDetailsAccess(),
            *this);
    }

    BlockDetails blockDetails(BlockDetails::Size length)
    {
        return constructGroup<BlockDetails>(
            BlockDetailsAccess(),
            length,
            *this);
    }

    BlockDetails blockDetails(BlockDetails::Size length, NoFieldsInit)
    {
        return setupGroup<BlockDetails>(
            BlockDetailsAccess(),
            length,
            *this);
    }

    ONIXS_ICEBOE_NODISCARD
    SecurityAltID securityAltId() const noexcept
    {
        return getGroup<SecurityAltID>(
            SecurityAltIDAccess(),
            *this);
    }

    ONIXS_ICEBOE_NODISCARD
    SecurityAltID securityAltId() noexcept
    {
        return getGroup<SecurityAltID>(
            SecurityAltIDAccess(),
            *this);
    }

    SecurityAltID securityAltId(SecurityAltID::Size length)
    {
        return constructGroup<SecurityAltID>(
            SecurityAltIDAccess(),
            length,
            *this);
    }

    SecurityAltID securityAltId(SecurityAltID::Size length, NoFieldsInit)
    {
        return setupGroup<SecurityAltID>(
            SecurityAltIDAccess(),
            length,
            *this);
    }

    ONIXS_ICEBOE_NODISCARD
    Legs legs() const noexcept
    {
        return getGroup<Legs>(LegsAccess(), *this);
    }

    ONIXS_ICEBOE_NODISCARD
    Legs legs() noexcept
    {
        return getGroup<Legs>(LegsAccess(), *this);
    }

    Legs legs(Legs::Size length)
    {
        return constructGroup<Legs>(
            LegsAccess(),
            length,
            *this);
    }

    Legs legs(Legs::Size length, NoFieldsInit)
    {
        return setupGroup<Legs>(
            LegsAccess(),
            length,
            *this);
    }

    ONIXS_ICEBOE_NODISCARD
    StrRef securityId() const noexcept
    {
        return getVariableLengthField(
            securityIDAccess(),
            *this);
    }
 
    ONIXS_ICEBOE_NODISCARD
    StrRef unitOfMeasure() const noexcept
    {
        return getVariableLengthField(
            unitOfMeasureAccess(),
            *this);
    }
 
    ONIXS_ICEBOE_NODISCARD
    StrRef priceDenomination() const noexcept
    {
        return getVariableLengthField(
            priceDenominationAccess(),
            *this);
    }
 
    ONIXS_ICEBOE_NODISCARD
    StrRef clearedAlias() const noexcept
    {
        return getVariableLengthField(
            clearedAliasAccess(),
            *this);
    }
 
    ONIXS_ICEBOE_NODISCARD
    StrRef securityDesc() const noexcept
    {
        return getVariableLengthField(
            securityDescAccess(),
            *this);
    }
 
    ONIXS_ICEBOE_NODISCARD
    StrRef priceUnit() const noexcept
    {
        return getVariableLengthField(priceUnitAccess(), *this);
    }
 
    ONIXS_ICEBOE_NODISCARD
    StrRef stripName() const noexcept
    {
        return getVariableLengthField(stripNameAccess(), *this);
    }
 
    ONIXS_ICEBOE_NODISCARD
    StrRef hubName() const noexcept
    {
        return getVariableLengthField(hubNameAccess(), *this);
    }
 
    ONIXS_ICEBOE_NODISCARD
    StrRef hubAlias() const noexcept
    {
        return getVariableLengthField(hubAliasAccess(), *this);
    }
 
    ONIXS_ICEBOE_NODISCARD
    StrRef securityExchange() const noexcept
    {
        return getVariableLengthField(
            securityExchangeAccess(),
            *this);
    }
 
    ONIXS_ICEBOE_NODISCARD
    StrRef strategySecurityId() const noexcept
    {
        return getVariableLengthField(
            strategySecurityIDAccess(),
            *this);
    }
 
    ONIXS_ICEBOE_NODISCARD
    StrRef physicalCode() const noexcept
    {
        return getVariableLengthField(
            physicalCodeAccess(),
            *this);
    }

    ThisType& securityId(StrRef value)
    {
        setVariableLengthField(
            securityIDAccess(),
            value,
            *this);
 
        return *this;
    }
 
    ThisType& unitOfMeasure(StrRef value)
    {
        setVariableLengthField(
            unitOfMeasureAccess(),
            value,
            *this);
 
        return *this;
    }
 
    ThisType& priceDenomination(StrRef value)
    {
        setVariableLengthField(
            priceDenominationAccess(),
            value,
            *this);
 
        return *this;
    }
 
    ThisType& clearedAlias(StrRef value)
    {
        setVariableLengthField(
            clearedAliasAccess(),
            value,
            *this);
 
        return *this;
    }
 
    ThisType& securityDesc(StrRef value)
    {
        setVariableLengthField(
            securityDescAccess(),
            value,
            *this);
 
        return *this;
    }
 
    ThisType& priceUnit(StrRef value)
    {
        setVariableLengthField(
            priceUnitAccess(),
            value,
            *this);
 
        return *this;
    }
 
    ThisType& stripName(StrRef value)
    {
        setVariableLengthField(
            stripNameAccess(),
            value,
            *this);
 
        return *this;
    }
 
    ThisType& hubName(StrRef value)
    {
        setVariableLengthField(
            hubNameAccess(),
            value,
            *this);
 
        return *this;
    }
 
    ThisType& hubAlias(StrRef value)
    {
        setVariableLengthField(
            hubAliasAccess(),
            value,
            *this);
 
        return *this;
    }
 
    ThisType& securityExchange(StrRef value)
    {
        setVariableLengthField(
            securityExchangeAccess(),
            value,
            *this);
 
        return *this;
    }
 
    ThisType& strategySecurityId(StrRef value)
    {
        setVariableLengthField(
            strategySecurityIDAccess(),
            value,
            *this);
 
        return *this;
    }
 
    ThisType& physicalCode(StrRef value)
    {
        setVariableLengthField(
            physicalCodeAccess(),
            value,
            *this);
 
        return *this;
    }

    constexpr
    static BlockLength minimalBlockLength(ONIXS_ICEBOE_UNUSED SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            146;
    }

    constexpr
    static BlockLength blockLength(SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            minimalBlockLength(version);
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static MessageSize getMinimalVariableFieldsSize(ONIXS_ICEBOE_UNUSED SchemaVersion version)
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            static_cast<MessageSize>(VarString16::Size) + static_cast<MessageSize>(VarString16::Size) + static_cast<MessageSize>(VarString16::Size) + static_cast<MessageSize>(VarString16::Size) + static_cast<MessageSize>(VarString16::Size) + static_cast<MessageSize>(VarString16::Size) + static_cast<MessageSize>(VarString16::Size) + static_cast<MessageSize>(VarString16::Size) + static_cast<MessageSize>(VarString16::Size) + static_cast<MessageSize>(VarString16::Size) + static_cast<MessageSize>(VarString16::Size) + static_cast<MessageSize>(VarString16::Size) + static_cast<MessageSize>(BlockDetails::EmptySize) + static_cast<MessageSize>(SecurityAltID::EmptySize) + static_cast<MessageSize>(Legs::EmptySize);
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static UInt64 getMaxMessageSize(UInt8) noexcept
    {
        return
            SbeMessage::getMaxMessageSize();
    }

    ThisType& resetVariableFields() noexcept
    {
        blockDetails(nullOpt);
        securityAltId(nullOpt);
        legs(nullOpt);
        securityId(nullOpt);
        unitOfMeasure(nullOpt);
        priceDenomination(nullOpt);
        clearedAlias(nullOpt);
        securityDesc(nullOpt);
        priceUnit(nullOpt);
        stripName(nullOpt);
        hubName(nullOpt);
        hubAlias(nullOpt);
        securityExchange(nullOpt);
        strategySecurityId(nullOpt);
        physicalCode(nullOpt);
        return *this;
    }

    ThisType& reset() noexcept
    {
        maturityDate(nullOpt);
        baseNumLots(nullOpt);
        impliedType(nullOpt);
        offExchangeIncrementPrice(nullOpt);
        offExchangeIncrementQty(nullOpt);
        numOfDecimalStrikePrice(nullOpt);
        numOfCycles(nullOpt);
        lotSizeMultiplier(nullOpt);
        blockOnly(nullOpt);
        flexAllowed(nullOpt);
        gtAllowed(nullOpt);
        overrideBlockMin(nullOpt);
 
        resetVariableFields();
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef className() noexcept
    {
        return constructStrRef("SecurityDefinitionReport_Strategy");
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef fixType() noexcept
    {
        return constructStrRef("UDS");
    }

    ONIXS_ICEBOE_NODISCARD
    std::string toString() const;

    ONIXS_ICEBOE_NODISCARD
    const void* tail() const noexcept
    {
        return
            toOpaquePtr(
                (physicalCode().end()));
    }

    ONIXS_ICEBOE_NODISCARD
    EncodedLength calculateBinarySize() const noexcept
    {
        return
            SbeMessage::calculateBinarySize(tail());
    }
 
private:
    void checkLength(
        EncodedLength length, SchemaVersion version) const
    {
       const EncodedLength minimalRequiredLength =
           minimalBlockLength(version) +
           MessageHeader::Size +
           getMinimalVariableFieldsSize(version);
 
       checkBinaryLength(
           *this, length, minimalRequiredLength);
    }

    void checkVarLenFields() const
    {
        groups().
            tail<BlockDetails>().
            tail<SecurityAltID>().
            checkVariableLengthFields<Legs>().
            checkTail<VarString16>().
            checkTail<VarString16>().
            checkTail<VarString16>().
            checkTail<VarString16>().
            checkTail<VarString16>().
            checkTail<VarString16>().
            checkTail<VarString16>().
            checkTail<VarString16>().
            checkTail<VarString16>().
            checkTail<VarString16>().
            checkTail<VarString16>().
            checkTail<VarString16>();
    }
 
    void checkCompatibility() const
    {
        assert(TemplateId == templateId());
 
        checkSchema<Schema>(schemaId(), version());
        checkLength(bufferSize(), version());
        checkVarLenFields();
    }

    struct BlockDetailsAccess
    {
        BlockDetails operator()(const SecurityDefinitionReport_Strategy& obj) const noexcept
        {
            return obj.
                groups().
                    head<BlockDetails>();
        }
    };

    void blockDetails(NullOpt) noexcept
    {
        resetGroup<BlockDetails>(
            BlockDetailsAccess(),
            *this);
    }

    struct SecurityAltIDAccess
    {
        SecurityAltID operator()(const SecurityDefinitionReport_Strategy& obj) const noexcept
        {
            return obj.
                groups().
                    tail<BlockDetails>().
                    head<SecurityAltID>();
        }
    };

    void securityAltId(NullOpt) noexcept
    {
        resetGroup<SecurityAltID>(
            SecurityAltIDAccess(),
            *this);
    }

    struct LegsAccess
    {
        Legs operator()(const SecurityDefinitionReport_Strategy& obj) const noexcept
        {
            return obj.
                groups().
                    tail<BlockDetails>().
                    tail<SecurityAltID>().
                    head<Legs>();
        }
    };

    void legs(NullOpt) noexcept
    {
        resetGroup<Legs>(LegsAccess(), *this);
    }

    struct securityIDAccess
    {
        VarString16& operator()(const SecurityDefinitionReport_Strategy& obj) const noexcept
        {
            return obj.
                groups().
                    tail<BlockDetails>().
                    tail<SecurityAltID>().
                    variableLengthFields<Legs>().
                    head<VarString16>();
        }
    };

    struct unitOfMeasureAccess
    {
        VarString16& operator()(const SecurityDefinitionReport_Strategy& obj) const noexcept
        {
            return obj.
                groups().
                    tail<BlockDetails>().
                    tail<SecurityAltID>().
                    variableLengthFields<Legs>().
                    tail<VarString16>().
                    head<VarString16>();
        }
    };

    struct priceDenominationAccess
    {
        VarString16& operator()(const SecurityDefinitionReport_Strategy& obj) const noexcept
        {
            return obj.
                groups().
                    tail<BlockDetails>().
                    tail<SecurityAltID>().
                    variableLengthFields<Legs>().
                    tail<VarString16>().
                    tail<VarString16>().
                    head<VarString16>();
        }
    };

    struct clearedAliasAccess
    {
        VarString16& operator()(const SecurityDefinitionReport_Strategy& obj) const noexcept
        {
            return obj.
                groups().
                    tail<BlockDetails>().
                    tail<SecurityAltID>().
                    variableLengthFields<Legs>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    head<VarString16>();
        }
    };

    struct securityDescAccess
    {
        VarString16& operator()(const SecurityDefinitionReport_Strategy& obj) const noexcept
        {
            return obj.
                groups().
                    tail<BlockDetails>().
                    tail<SecurityAltID>().
                    variableLengthFields<Legs>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    head<VarString16>();
        }
    };

    struct priceUnitAccess
    {
        VarString16& operator()(const SecurityDefinitionReport_Strategy& obj) const noexcept
        {
            return obj.
                groups().
                    tail<BlockDetails>().
                    tail<SecurityAltID>().
                    variableLengthFields<Legs>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    head<VarString16>();
        }
    };

    struct stripNameAccess
    {
        VarString16& operator()(const SecurityDefinitionReport_Strategy& obj) const noexcept
        {
            return obj.
                groups().
                    tail<BlockDetails>().
                    tail<SecurityAltID>().
                    variableLengthFields<Legs>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    head<VarString16>();
        }
    };

    struct hubNameAccess
    {
        VarString16& operator()(const SecurityDefinitionReport_Strategy& obj) const noexcept
        {
            return obj.
                groups().
                    tail<BlockDetails>().
                    tail<SecurityAltID>().
                    variableLengthFields<Legs>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    head<VarString16>();
        }
    };

    struct hubAliasAccess
    {
        VarString16& operator()(const SecurityDefinitionReport_Strategy& obj) const noexcept
        {
            return obj.
                groups().
                    tail<BlockDetails>().
                    tail<SecurityAltID>().
                    variableLengthFields<Legs>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    head<VarString16>();
        }
    };

    struct securityExchangeAccess
    {
        VarString16& operator()(const SecurityDefinitionReport_Strategy& obj) const noexcept
        {
            return obj.
                groups().
                    tail<BlockDetails>().
                    tail<SecurityAltID>().
                    variableLengthFields<Legs>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    head<VarString16>();
        }
    };

    struct strategySecurityIDAccess
    {
        VarString16& operator()(const SecurityDefinitionReport_Strategy& obj) const noexcept
        {
            return obj.
                groups().
                    tail<BlockDetails>().
                    tail<SecurityAltID>().
                    variableLengthFields<Legs>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    head<VarString16>();
        }
    };

    struct physicalCodeAccess
    {
        VarString16& operator()(const SecurityDefinitionReport_Strategy& obj) const noexcept
        {
            return obj.
                groups().
                    tail<BlockDetails>().
                    tail<SecurityAltID>().
                    variableLengthFields<Legs>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    head<VarString16>();
        }
    };

    ThisType& securityId(NullOpt) noexcept
    {
        setVariableLengthFieldToNull(
            securityIDAccess(),
            *this);
 
        return *this;
    }

    ThisType& unitOfMeasure(NullOpt) noexcept
    {
        setVariableLengthFieldToNull(
            unitOfMeasureAccess(),
            *this);
 
        return *this;
    }

    ThisType& priceDenomination(NullOpt) noexcept
    {
        setVariableLengthFieldToNull(
            priceDenominationAccess(),
            *this);
 
        return *this;
    }

    ThisType& clearedAlias(NullOpt) noexcept
    {
        setVariableLengthFieldToNull(
            clearedAliasAccess(),
            *this);
 
        return *this;
    }

    ThisType& securityDesc(NullOpt) noexcept
    {
        setVariableLengthFieldToNull(
            securityDescAccess(),
            *this);
 
        return *this;
    }

    ThisType& priceUnit(NullOpt) noexcept
    {
        setVariableLengthFieldToNull(priceUnitAccess(), *this);
 
        return *this;
    }

    ThisType& stripName(NullOpt) noexcept
    {
        setVariableLengthFieldToNull(stripNameAccess(), *this);
 
        return *this;
    }

    ThisType& hubName(NullOpt) noexcept
    {
        setVariableLengthFieldToNull(hubNameAccess(), *this);
 
        return *this;
    }

    ThisType& hubAlias(NullOpt) noexcept
    {
        setVariableLengthFieldToNull(hubAliasAccess(), *this);
 
        return *this;
    }

    ThisType& securityExchange(NullOpt) noexcept
    {
        setVariableLengthFieldToNull(
            securityExchangeAccess(),
            *this);
 
        return *this;
    }

    ThisType& strategySecurityId(NullOpt) noexcept
    {
        setVariableLengthFieldToNull(
            strategySecurityIDAccess(),
            *this);
 
        return *this;
    }

    ThisType& physicalCode(NullOpt) noexcept
    {
        setVariableLengthFieldToNull(
            physicalCodeAccess(),
            *this);
 
        return *this;
    }
};

struct
SecurityDefinitionReport
: SbeMessage
{
    typedef SchemaTraits Schema;

    typedef SecurityDefinitionReport ThisType;

    enum { TemplateId = 115 };

    struct
    BlockDetailsEntry : SbeGroupEntry
    <
        GroupSizeEncoding::BlockLength
    >
    {
        typedef
        SbeGroupEntry
        <
            GroupSizeEncoding::BlockLength
        >
        Base;

        typedef BlockDetailsEntry ThisType;

        BlockDetailsEntry(void* data, EncodedLength length, SchemaVersion version)
          : Base(data, numericCast<Base::BlockLength>(length), version)
        {
            assert(version >= Schema::MinimalVersion);
            assert(length >= minimalBlockLength(version));
        }

        ThisType& resetVariableFields() noexcept
        {
            return *this;
        }

        ThisType& reset() noexcept
        {
            blockDetailsTradeType(nullOpt);
 
            resetVariableFields();
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto blockDetailsBlockType() const noexcept
        {
            constexpr BlockLength offset = 0;
 
            return enumeration<BlockTypeEnum>(offset);
        }

        ThisType& blockDetailsBlockType(BlockTypeEnum value) noexcept
        {
            constexpr BlockLength offset = 0;
 
            setEnumeration<BlockTypeEnum>(offset, value);
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto blockDetailsTradeType() const noexcept
        {
            constexpr BlockLength offset = 1;
            constexpr BlockLength length = 3;
 
            return fixedStr<length>(offset, optional);
        }

        ThisType& blockDetailsTradeType(StrRef value) noexcept
        {
            constexpr BlockLength offset = 1;
            constexpr BlockLength length = 3;
 
            setFixedStr<length>(offset, value);
            return *this;
        }
 
        ThisType& blockDetailsTradeType(NullOpt) noexcept
        {
            constexpr BlockLength offset = 1;
            constexpr BlockLength length = 3;
 
            setFixedStr<length>(offset, StrRef());
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto blockDetailsMinQty() const noexcept
        {
            constexpr BlockLength offset = 4;
 
            return ordinary<Decimal9>(offset);
        }

        ThisType& blockDetailsMinQty(Decimal9 value) noexcept
        {
            constexpr BlockLength offset = 4;
 
            setOrdinary(offset, value);
            return *this;
        }

        constexpr
        static BlockLength blockLength(SchemaVersion version) noexcept
        {
            return
                ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
                minimalBlockLength(version);
        }

        constexpr
        static BlockLength minimalBlockLength(ONIXS_ICEBOE_UNUSED SchemaVersion version) noexcept
        {
            return
                ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
                12;
        }

        ONIXS_ICEBOE_NODISCARD
        constexpr
        static StrRef className() noexcept
        {
            return constructStrRef("SecurityDefinitionReport.BlockDetailsEntry");
        }
    };

    typedef
    SbeGroup<BlockDetailsEntry, GroupSizeEncoding, MessageSize>
    BlockDetails;

    struct
    SecurityAltIDEntry : SbeGroupEntry
    <
        GroupSizeEncoding::BlockLength
    >
    {
        typedef
        SbeGroupEntry
        <
            GroupSizeEncoding::BlockLength
        >
        Base;

        typedef SecurityAltIDEntry ThisType;

        SecurityAltIDEntry(void* data, EncodedLength length, SchemaVersion version)
          : Base(data, numericCast<Base::BlockLength>(length), version)
        {
            assert(version >= Schema::MinimalVersion);
            assert(length >= minimalBlockLength(version));
        }

        ThisType& resetVariableFields() noexcept
        {
            return *this;
        }

        ThisType& reset() noexcept
        {
            securityAltId(nullOpt);
            securityAltIdSource(nullOpt);
 
            resetVariableFields();
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto securityAltId() const noexcept
        {
            constexpr BlockLength offset = 0;
            constexpr BlockLength length = 30;
 
            return fixedStr<length>(offset, optional);
        }

        ThisType& securityAltId(StrRef value) noexcept
        {
            constexpr BlockLength offset = 0;
            constexpr BlockLength length = 30;
 
            setFixedStr<length>(offset, value);
            return *this;
        }
 
        ThisType& securityAltId(NullOpt) noexcept
        {
            constexpr BlockLength offset = 0;
            constexpr BlockLength length = 30;
 
            setFixedStr<length>(offset, StrRef());
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto securityAltIdSource() const noexcept
        {
            constexpr BlockLength offset = 30;
            constexpr BlockLength length = 3;
 
            return fixedStr<length>(offset, optional);
        }

        ThisType& securityAltIdSource(StrRef value) noexcept
        {
            constexpr BlockLength offset = 30;
            constexpr BlockLength length = 3;
 
            setFixedStr<length>(offset, value);
            return *this;
        }
 
        ThisType& securityAltIdSource(NullOpt) noexcept
        {
            constexpr BlockLength offset = 30;
            constexpr BlockLength length = 3;
 
            setFixedStr<length>(offset, StrRef());
            return *this;
        }

        constexpr
        static BlockLength blockLength(SchemaVersion version) noexcept
        {
            return
                ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
                minimalBlockLength(version);
        }

        constexpr
        static BlockLength minimalBlockLength(ONIXS_ICEBOE_UNUSED SchemaVersion version) noexcept
        {
            return
                ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
                33;
        }

        ONIXS_ICEBOE_NODISCARD
        constexpr
        static StrRef className() noexcept
        {
            return constructStrRef("SecurityDefinitionReport.SecurityAltIDEntry");
        }
    };

    typedef
    SbeGroup<SecurityAltIDEntry, GroupSizeEncoding, MessageSize>
    SecurityAltID;

    SecurityDefinitionReport() = default;

    SecurityDefinitionReport(void* data, EncodedLength length, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        reset();
    }

    SecurityDefinitionReport(void* data, EncodedLength length, NoFieldsInit, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        resetVariableFields();
    }

    SecurityDefinitionReport(void* data, EncodedLength length, NoInit)
      : SbeMessage(data, length)
    {
        checkCompatibility();
    }

    explicit
    SecurityDefinitionReport(const SbeMessage& message)
      : SbeMessage(message)
    {
        assert(message.valid());
 
        checkCompatibility();
    }

    SecurityDefinitionReport(void* data, EncodedLength length, NoInit, NoCheck) noexcept
      : SbeMessage(data, length, NoCheck())
    {
        assert(schemaId() == Schema::Id);
        assert(version() >= Schema::MinimalVersion);
        assert(TemplateId == templateId());
    }

    ONIXS_ICEBOE_NODISCARD
    auto securityReqId() const noexcept
    {
        constexpr BlockLength offset = 0;
 
        return ordinary<Int32>(offset);
    }

    ThisType& securityReqId(Int32 value) noexcept
    {
        constexpr BlockLength offset = 0;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto securityResponseType() const noexcept
    {
        constexpr BlockLength offset = 4;
 
        return enumeration<SecurityResponseTypeEnum>(offset);
    }

    ThisType& securityResponseType(SecurityResponseTypeEnum value) noexcept
    {
        constexpr BlockLength offset = 4;
 
        setEnumeration<SecurityResponseTypeEnum>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto securityResponseId() const noexcept
    {
        constexpr BlockLength offset = 5;
 
        return ordinary<Int32>(offset);
    }

    ThisType& securityResponseId(Int32 value) noexcept
    {
        constexpr BlockLength offset = 5;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto marketTypeId() const noexcept
    {
        constexpr BlockLength offset = 9;
 
        return ordinary<Int32>(offset);
    }

    ThisType& marketTypeId(Int32 value) noexcept
    {
        constexpr BlockLength offset = 9;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto symbol() const noexcept
    {
        constexpr BlockLength offset = 13;
 
        return ordinary<Int32>(offset);
    }

    ThisType& symbol(Int32 value) noexcept
    {
        constexpr BlockLength offset = 13;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto exchangeSilo() const noexcept
    {
        constexpr BlockLength offset = 17;
 
        return enumeration<ExchangeSiloEnum>(offset);
    }

    ThisType& exchangeSilo(ExchangeSiloEnum value) noexcept
    {
        constexpr BlockLength offset = 17;
 
        setEnumeration<ExchangeSiloEnum>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto rpts() const noexcept
    {
        constexpr BlockLength offset = 18;
 
        return ordinary<Int32>(offset);
    }

    ThisType& rpts(Int32 value) noexcept
    {
        constexpr BlockLength offset = 18;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto listSeqNo() const noexcept
    {
        constexpr BlockLength offset = 22;
 
        return ordinary<Int32>(offset);
    }

    ThisType& listSeqNo(Int32 value) noexcept
    {
        constexpr BlockLength offset = 22;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto underlyingSymbol() const noexcept
    {
        constexpr BlockLength offset = 26;
 
        return ordinary<Int32>(offset);
    }

    ThisType& underlyingSymbol(Int32 value) noexcept
    {
        constexpr BlockLength offset = 26;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto cfiCode() const noexcept
    {
        constexpr BlockLength offset = 30;
        constexpr BlockLength length = 12;
 
        return fixedStr<length>(offset);
    }

    ThisType& cfiCode(StrRef value) noexcept
    {
        constexpr BlockLength offset = 30;
        constexpr BlockLength length = 12;
 
        setFixedStr<length>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto securitySubType() const noexcept
    {
        constexpr BlockLength offset = 42;
 
        return ordinary<NullInt16NULL>(offset, optional);
    }

    ThisType& securitySubType(Int16NULL value) noexcept
    {
        constexpr BlockLength offset = 42;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& securitySubType(NullOpt) noexcept
    {
        constexpr BlockLength offset = 42;
 
        setOrdinary(offset, NullInt16NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto maturityDate() const noexcept(dateToTimestamp::Nothrow)
    {
        constexpr BlockLength offset = 44;
        return convertible<NullUTCDateOnly, dateToTimestamp>(offset, optional);
    }

    ThisType& maturityDate(Timestamp value) noexcept(timestampToDate::Nothrow)
    {
        constexpr BlockLength offset = 44;
 
        setOrdinary(offset, convert<timestampToDate>(value));
        return *this;
    }
 
    ThisType& maturityDate(NullOpt) noexcept
    {
        constexpr BlockLength offset = 44;
 
        setOrdinary(offset, NullUTCDateOnly());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto screenLastTradeDate() const noexcept(dateToTimestamp::Nothrow)
    {
        constexpr BlockLength offset = 46;
        return convertible<NullUTCDateOnly, dateToTimestamp>(offset, optional);
    }

    ThisType& screenLastTradeDate(Timestamp value) noexcept(timestampToDate::Nothrow)
    {
        constexpr BlockLength offset = 46;
 
        setOrdinary(offset, convert<timestampToDate>(value));
        return *this;
    }
 
    ThisType& screenLastTradeDate(NullOpt) noexcept
    {
        constexpr BlockLength offset = 46;
 
        setOrdinary(offset, NullUTCDateOnly());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto contractMultiplier() const noexcept
    {
        constexpr BlockLength offset = 48;
 
        return ordinary<Int32>(offset);
    }

    ThisType& contractMultiplier(Int32 value) noexcept
    {
        constexpr BlockLength offset = 48;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto startDate() const noexcept(dateToTimestamp::Nothrow)
    {
        constexpr BlockLength offset = 52;
        return convertible<NullUTCDateOnly, dateToTimestamp>(offset, optional);
    }

    ThisType& startDate(Timestamp value) noexcept(timestampToDate::Nothrow)
    {
        constexpr BlockLength offset = 52;
 
        setOrdinary(offset, convert<timestampToDate>(value));
        return *this;
    }
 
    ThisType& startDate(NullOpt) noexcept
    {
        constexpr BlockLength offset = 52;
 
        setOrdinary(offset, NullUTCDateOnly());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto endDate() const noexcept(dateToTimestamp::Nothrow)
    {
        constexpr BlockLength offset = 54;
        return convertible<NullUTCDateOnly, dateToTimestamp>(offset, optional);
    }

    ThisType& endDate(Timestamp value) noexcept(timestampToDate::Nothrow)
    {
        constexpr BlockLength offset = 54;
 
        setOrdinary(offset, convert<timestampToDate>(value));
        return *this;
    }
 
    ThisType& endDate(NullOpt) noexcept
    {
        constexpr BlockLength offset = 54;
 
        setOrdinary(offset, NullUTCDateOnly());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto putOrCall() const noexcept
    {
        constexpr BlockLength offset = 56;
 
        return enumeration<BooleanEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& putOrCall(BooleanEnum value) noexcept
    {
        constexpr BlockLength offset = 56;
 
        setEnumeration<BooleanEnum>(offset, value);
        return *this;
    }
 
    ThisType& putOrCall(NullOpt) noexcept
    {
        constexpr BlockLength offset = 56;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto strikePrice() const noexcept
    {
        constexpr BlockLength offset = 57;
 
        return ordinary<NullDecimal9>(offset, optional);
    }

    ThisType& strikePrice(Decimal9 value) noexcept
    {
        constexpr BlockLength offset = 57;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& strikePrice(NullOpt) noexcept
    {
        constexpr BlockLength offset = 57;
 
        setOrdinary(offset, NullDecimal9());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto securityTradingStatus() const noexcept
    {
        constexpr BlockLength offset = 65;
 
        return enumeration<SecurityTradingStatusEnum>(offset);
    }

    ThisType& securityTradingStatus(SecurityTradingStatusEnum value) noexcept
    {
        constexpr BlockLength offset = 65;
 
        setEnumeration<SecurityTradingStatusEnum>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto currency() const noexcept
    {
        constexpr BlockLength offset = 66;
        constexpr BlockLength length = 12;
 
        return fixedStr<length>(offset, optional);
    }

    ThisType& currency(StrRef value) noexcept
    {
        constexpr BlockLength offset = 66;
        constexpr BlockLength length = 12;
 
        setFixedStr<length>(offset, value);
        return *this;
    }
 
    ThisType& currency(NullOpt) noexcept
    {
        constexpr BlockLength offset = 66;
        constexpr BlockLength length = 12;
 
        setFixedStr<length>(offset, StrRef());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto settlMethod() const noexcept
    {
        constexpr BlockLength offset = 78;
 
        return enumeration<SettlMethodEnum>(offset);
    }

    ThisType& settlMethod(SettlMethodEnum value) noexcept
    {
        constexpr BlockLength offset = 78;
 
        setEnumeration<SettlMethodEnum>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto strikeExerciseStyle() const noexcept
    {
        constexpr BlockLength offset = 79;
 
        return enumeration<StrikeExerciseStyleEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& strikeExerciseStyle(StrikeExerciseStyleEnum value) noexcept
    {
        constexpr BlockLength offset = 79;
 
        setEnumeration<StrikeExerciseStyleEnum>(offset, value);
        return *this;
    }
 
    ThisType& strikeExerciseStyle(NullOpt) noexcept
    {
        constexpr BlockLength offset = 79;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto incrementQty() const noexcept
    {
        constexpr BlockLength offset = 80;
 
        return ordinary<Decimal9>(offset);
    }

    ThisType& incrementQty(Decimal9 value) noexcept
    {
        constexpr BlockLength offset = 80;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto incrementPrice() const noexcept
    {
        constexpr BlockLength offset = 88;
 
        return ordinary<Decimal9>(offset);
    }

    ThisType& incrementPrice(Decimal9 value) noexcept
    {
        constexpr BlockLength offset = 88;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto minPrice() const noexcept
    {
        constexpr BlockLength offset = 96;
 
        return ordinary<Decimal9>(offset);
    }

    ThisType& minPrice(Decimal9 value) noexcept
    {
        constexpr BlockLength offset = 96;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto maxPrice() const noexcept
    {
        constexpr BlockLength offset = 104;
 
        return ordinary<Decimal9>(offset);
    }

    ThisType& maxPrice(Decimal9 value) noexcept
    {
        constexpr BlockLength offset = 104;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto offExchangeIncrementPrice() const noexcept
    {
        constexpr BlockLength offset = 112;
 
        return ordinary<Decimal9>(offset);
    }

    ThisType& offExchangeIncrementPrice(Decimal9 value) noexcept
    {
        constexpr BlockLength offset = 112;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto offExchangeIncrementQty() const noexcept
    {
        constexpr BlockLength offset = 120;
 
        return ordinary<Decimal9>(offset);
    }

    ThisType& offExchangeIncrementQty(Decimal9 value) noexcept
    {
        constexpr BlockLength offset = 120;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto screenTickValue() const noexcept
    {
        constexpr BlockLength offset = 128;
 
        return ordinary<Decimal9>(offset);
    }

    ThisType& screenTickValue(Decimal9 value) noexcept
    {
        constexpr BlockLength offset = 128;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto blockTickValue() const noexcept
    {
        constexpr BlockLength offset = 136;
 
        return ordinary<Decimal9>(offset);
    }

    ThisType& blockTickValue(Decimal9 value) noexcept
    {
        constexpr BlockLength offset = 136;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto lotSize() const noexcept
    {
        constexpr BlockLength offset = 144;
 
        return ordinary<Int32>(offset);
    }

    ThisType& lotSize(Int32 value) noexcept
    {
        constexpr BlockLength offset = 144;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto contractSize() const noexcept
    {
        constexpr BlockLength offset = 148;
 
        return ordinary<Int32>(offset);
    }

    ThisType& contractSize(Int32 value) noexcept
    {
        constexpr BlockLength offset = 148;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto numOfDecimalPrice() const noexcept
    {
        constexpr BlockLength offset = 152;
 
        return ordinary<Int8>(offset);
    }

    ThisType& numOfDecimalPrice(Int8 value) noexcept
    {
        constexpr BlockLength offset = 152;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto numOfDecimalQty() const noexcept
    {
        constexpr BlockLength offset = 153;
 
        return ordinary<Int8>(offset);
    }

    ThisType& numOfDecimalQty(Int8 value) noexcept
    {
        constexpr BlockLength offset = 153;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto granularity() const noexcept
    {
        constexpr BlockLength offset = 154;
        constexpr BlockLength length = 12;
 
        return fixedStr<length>(offset);
    }

    ThisType& granularity(StrRef value) noexcept
    {
        constexpr BlockLength offset = 154;
        constexpr BlockLength length = 12;
 
        setFixedStr<length>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto baseNumLots() const noexcept
    {
        constexpr BlockLength offset = 166;
 
        return ordinary<NullInt32NULL>(offset, optional);
    }

    ThisType& baseNumLots(Int32NULL value) noexcept
    {
        constexpr BlockLength offset = 166;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& baseNumLots(NullOpt) noexcept
    {
        constexpr BlockLength offset = 166;
 
        setOrdinary(offset, NullInt32NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto tickValue() const noexcept
    {
        constexpr BlockLength offset = 170;
 
        return ordinary<Decimal9>(offset);
    }

    ThisType& tickValue(Decimal9 value) noexcept
    {
        constexpr BlockLength offset = 170;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto productId() const noexcept
    {
        constexpr BlockLength offset = 178;
 
        return ordinary<Int32>(offset);
    }

    ThisType& productId(Int32 value) noexcept
    {
        constexpr BlockLength offset = 178;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto clearable() const noexcept
    {
        constexpr BlockLength offset = 182;
 
        return enumeration<BooleanEnum>(offset);
    }

    ThisType& clearable(BooleanEnum value) noexcept
    {
        constexpr BlockLength offset = 182;
 
        setEnumeration<BooleanEnum>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto hedgeProductId() const noexcept
    {
        constexpr BlockLength offset = 183;
 
        return ordinary<NullInt32NULL>(offset, optional);
    }

    ThisType& hedgeProductId(Int32NULL value) noexcept
    {
        constexpr BlockLength offset = 183;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& hedgeProductId(NullOpt) noexcept
    {
        constexpr BlockLength offset = 183;
 
        setOrdinary(offset, NullInt32NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto hedgeMarketId() const noexcept
    {
        constexpr BlockLength offset = 187;
 
        return ordinary<NullInt32NULL>(offset, optional);
    }

    ThisType& hedgeMarketId(Int32NULL value) noexcept
    {
        constexpr BlockLength offset = 187;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& hedgeMarketId(NullOpt) noexcept
    {
        constexpr BlockLength offset = 187;
 
        setOrdinary(offset, NullInt32NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto hedgeOnly() const noexcept
    {
        constexpr BlockLength offset = 191;
 
        return enumeration<BooleanEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& hedgeOnly(BooleanEnum value) noexcept
    {
        constexpr BlockLength offset = 191;
 
        setEnumeration<BooleanEnum>(offset, value);
        return *this;
    }
 
    ThisType& hedgeOnly(NullOpt) noexcept
    {
        constexpr BlockLength offset = 191;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto isDividendAdjusted() const noexcept
    {
        constexpr BlockLength offset = 192;
 
        return enumeration<BooleanEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& isDividendAdjusted(BooleanEnum value) noexcept
    {
        constexpr BlockLength offset = 192;
 
        setEnumeration<BooleanEnum>(offset, value);
        return *this;
    }
 
    ThisType& isDividendAdjusted(NullOpt) noexcept
    {
        constexpr BlockLength offset = 192;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto denominator() const noexcept
    {
        constexpr BlockLength offset = 193;
 
        return ordinary<Int32>(offset);
    }

    ThisType& denominator(Int32 value) noexcept
    {
        constexpr BlockLength offset = 193;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto initialMargin() const noexcept
    {
        constexpr BlockLength offset = 197;
 
        return ordinary<Int32>(offset);
    }

    ThisType& initialMargin(Int32 value) noexcept
    {
        constexpr BlockLength offset = 197;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto impliedType() const noexcept
    {
        constexpr BlockLength offset = 201;
 
        return ordinary<NullCharType>(offset, optional);
    }

    ThisType& impliedType(CharType value) noexcept
    {
        constexpr BlockLength offset = 201;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& impliedType(NullOpt) noexcept
    {
        constexpr BlockLength offset = 201;
 
        setOrdinary(offset, NullCharType());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto numOfDecimalStrikePrice() const noexcept
    {
        constexpr BlockLength offset = 202;
 
        return ordinary<NullInt8NULL>(offset, optional);
    }

    ThisType& numOfDecimalStrikePrice(Int8NULL value) noexcept
    {
        constexpr BlockLength offset = 202;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& numOfDecimalStrikePrice(NullOpt) noexcept
    {
        constexpr BlockLength offset = 202;
 
        setOrdinary(offset, NullInt8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto numOfCycles() const noexcept
    {
        constexpr BlockLength offset = 203;
 
        return ordinary<Int16>(offset);
    }

    ThisType& numOfCycles(Int16 value) noexcept
    {
        constexpr BlockLength offset = 203;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto lotSizeMultiplier() const noexcept
    {
        constexpr BlockLength offset = 205;
 
        return ordinary<Decimal9>(offset);
    }

    ThisType& lotSizeMultiplier(Decimal9 value) noexcept
    {
        constexpr BlockLength offset = 205;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto stripType() const noexcept
    {
        constexpr BlockLength offset = 213;
 
        return ordinary<Int16>(offset);
    }

    ThisType& stripType(Int16 value) noexcept
    {
        constexpr BlockLength offset = 213;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto stripId() const noexcept
    {
        constexpr BlockLength offset = 215;
 
        return ordinary<Int32>(offset);
    }

    ThisType& stripId(Int32 value) noexcept
    {
        constexpr BlockLength offset = 215;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto blockOnly() const noexcept
    {
        constexpr BlockLength offset = 219;
 
        return enumeration<BooleanEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& blockOnly(BooleanEnum value) noexcept
    {
        constexpr BlockLength offset = 219;
 
        setEnumeration<BooleanEnum>(offset, value);
        return *this;
    }
 
    ThisType& blockOnly(NullOpt) noexcept
    {
        constexpr BlockLength offset = 219;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto flexAllowed() const noexcept
    {
        constexpr BlockLength offset = 220;
 
        return enumeration<BooleanEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& flexAllowed(BooleanEnum value) noexcept
    {
        constexpr BlockLength offset = 220;
 
        setEnumeration<BooleanEnum>(offset, value);
        return *this;
    }
 
    ThisType& flexAllowed(NullOpt) noexcept
    {
        constexpr BlockLength offset = 220;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto gtAllowed() const noexcept
    {
        constexpr BlockLength offset = 221;
 
        return enumeration<BooleanEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& gtAllowed(BooleanEnum value) noexcept
    {
        constexpr BlockLength offset = 221;
 
        setEnumeration<BooleanEnum>(offset, value);
        return *this;
    }
 
    ThisType& gtAllowed(NullOpt) noexcept
    {
        constexpr BlockLength offset = 221;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto aonAllowed() const noexcept
    {
        constexpr BlockLength offset = 222;
 
        return enumeration<BooleanEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& aonAllowed(BooleanEnum value) noexcept
    {
        constexpr BlockLength offset = 222;
 
        setEnumeration<BooleanEnum>(offset, value);
        return *this;
    }
 
    ThisType& aonAllowed(NullOpt) noexcept
    {
        constexpr BlockLength offset = 222;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto mifidRegulatedMarket() const noexcept
    {
        constexpr BlockLength offset = 223;
 
        return enumeration<BooleanEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& mifidRegulatedMarket(BooleanEnum value) noexcept
    {
        constexpr BlockLength offset = 223;
 
        setEnumeration<BooleanEnum>(offset, value);
        return *this;
    }
 
    ThisType& mifidRegulatedMarket(NullOpt) noexcept
    {
        constexpr BlockLength offset = 223;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto flexStrikeAllowed() const noexcept
    {
        constexpr BlockLength offset = 224;
 
        return enumeration<BooleanEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& flexStrikeAllowed(BooleanEnum value) noexcept
    {
        constexpr BlockLength offset = 224;
 
        setEnumeration<BooleanEnum>(offset, value);
        return *this;
    }
 
    ThisType& flexStrikeAllowed(NullOpt) noexcept
    {
        constexpr BlockLength offset = 224;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto hubId() const noexcept
    {
        constexpr BlockLength offset = 225;
 
        return ordinary<Int32>(offset);
    }

    ThisType& hubId(Int32 value) noexcept
    {
        constexpr BlockLength offset = 225;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto overrideBlockMin() const noexcept
    {
        constexpr BlockLength offset = 229;
 
        return enumeration<BooleanEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& overrideBlockMin(BooleanEnum value) noexcept
    {
        constexpr BlockLength offset = 229;
 
        setEnumeration<BooleanEnum>(offset, value);
        return *this;
    }
 
    ThisType& overrideBlockMin(NullOpt) noexcept
    {
        constexpr BlockLength offset = 229;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto testMarketIndicator() const noexcept
    {
        constexpr BlockLength offset = 230;
 
        return enumeration<BooleanEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& testMarketIndicator(BooleanEnum value) noexcept
    {
        constexpr BlockLength offset = 230;
 
        setEnumeration<BooleanEnum>(offset, value);
        return *this;
    }
 
    ThisType& testMarketIndicator(NullOpt) noexcept
    {
        constexpr BlockLength offset = 230;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto refSprdProductId() const noexcept
    {
        constexpr BlockLength offset = 231;
 
        return ordinary<NullInt32NULL>(offset, optional);
    }

    ThisType& refSprdProductId(Int32NULL value) noexcept
    {
        constexpr BlockLength offset = 231;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& refSprdProductId(NullOpt) noexcept
    {
        constexpr BlockLength offset = 231;
 
        setOrdinary(offset, NullInt32NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto marketTransparencyType() const noexcept
    {
        constexpr BlockLength offset = 235;
 
        return enumeration<BooleanEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& marketTransparencyType(BooleanEnum value) noexcept
    {
        constexpr BlockLength offset = 235;
 
        setEnumeration<BooleanEnum>(offset, value);
        return *this;
    }
 
    ThisType& marketTransparencyType(NullOpt) noexcept
    {
        constexpr BlockLength offset = 235;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto nCommoditizedMarket() const noexcept
    {
        constexpr BlockLength offset = 236;
 
        return enumeration<BooleanEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& nCommoditizedMarket(BooleanEnum value) noexcept
    {
        constexpr BlockLength offset = 236;
 
        setEnumeration<BooleanEnum>(offset, value);
        return *this;
    }
 
    ThisType& nCommoditizedMarket(NullOpt) noexcept
    {
        constexpr BlockLength offset = 236;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    BlockDetails blockDetails() const noexcept
    {
        return getGroup<BlockDetails>(
            BlockDetailsAccess(),
            *this);
    }

    ONIXS_ICEBOE_NODISCARD
    BlockDetails blockDetails() noexcept
    {
        return getGroup<BlockDetails>(
            BlockDetailsAccess(),
            *this);
    }

    BlockDetails blockDetails(BlockDetails::Size length)
    {
        return constructGroup<BlockDetails>(
            BlockDetailsAccess(),
            length,
            *this);
    }

    BlockDetails blockDetails(BlockDetails::Size length, NoFieldsInit)
    {
        return setupGroup<BlockDetails>(
            BlockDetailsAccess(),
            length,
            *this);
    }

    ONIXS_ICEBOE_NODISCARD
    SecurityAltID securityAltId() const noexcept
    {
        return getGroup<SecurityAltID>(
            SecurityAltIDAccess(),
            *this);
    }

    ONIXS_ICEBOE_NODISCARD
    SecurityAltID securityAltId() noexcept
    {
        return getGroup<SecurityAltID>(
            SecurityAltIDAccess(),
            *this);
    }

    SecurityAltID securityAltId(SecurityAltID::Size length)
    {
        return constructGroup<SecurityAltID>(
            SecurityAltIDAccess(),
            length,
            *this);
    }

    SecurityAltID securityAltId(SecurityAltID::Size length, NoFieldsInit)
    {
        return setupGroup<SecurityAltID>(
            SecurityAltIDAccess(),
            length,
            *this);
    }
 
    ONIXS_ICEBOE_NODISCARD
    StrRef securityId() const noexcept
    {
        return getVariableLengthField(
            securityIDAccess(),
            *this);
    }
 
    ONIXS_ICEBOE_NODISCARD
    StrRef unitOfMeasure() const noexcept
    {
        return getVariableLengthField(
            unitOfMeasureAccess(),
            *this);
    }
 
    ONIXS_ICEBOE_NODISCARD
    StrRef priceDenomination() const noexcept
    {
        return getVariableLengthField(
            priceDenominationAccess(),
            *this);
    }
 
    ONIXS_ICEBOE_NODISCARD
    StrRef clearedAlias() const noexcept
    {
        return getVariableLengthField(
            clearedAliasAccess(),
            *this);
    }
 
    ONIXS_ICEBOE_NODISCARD
    StrRef securityDesc() const noexcept
    {
        return getVariableLengthField(
            securityDescAccess(),
            *this);
    }
 
    ONIXS_ICEBOE_NODISCARD
    StrRef priceUnit() const noexcept
    {
        return getVariableLengthField(priceUnitAccess(), *this);
    }
 
    ONIXS_ICEBOE_NODISCARD
    StrRef stripName() const noexcept
    {
        return getVariableLengthField(stripNameAccess(), *this);
    }
 
    ONIXS_ICEBOE_NODISCARD
    StrRef hubName() const noexcept
    {
        return getVariableLengthField(hubNameAccess(), *this);
    }
 
    ONIXS_ICEBOE_NODISCARD
    StrRef hubAlias() const noexcept
    {
        return getVariableLengthField(hubAliasAccess(), *this);
    }
 
    ONIXS_ICEBOE_NODISCARD
    StrRef securityExchange() const noexcept
    {
        return getVariableLengthField(
            securityExchangeAccess(),
            *this);
    }
 
    ONIXS_ICEBOE_NODISCARD
    StrRef physicalCode() const noexcept
    {
        return getVariableLengthField(
            physicalCodeAccess(),
            *this);
    }
 
    ONIXS_ICEBOE_NODISCARD
    StrRef homeExchange() const noexcept
    {
        return getVariableLengthField(
            homeExchangeAccess(),
            *this);
    }
 
    ThisType& securityId(StrRef value)
    {
        setVariableLengthField(
            securityIDAccess(),
            value,
            *this);
 
        return *this;
    }
 
    ThisType& unitOfMeasure(StrRef value)
    {
        setVariableLengthField(
            unitOfMeasureAccess(),
            value,
            *this);
 
        return *this;
    }
 
    ThisType& priceDenomination(StrRef value)
    {
        setVariableLengthField(
            priceDenominationAccess(),
            value,
            *this);
 
        return *this;
    }
 
    ThisType& clearedAlias(StrRef value)
    {
        setVariableLengthField(
            clearedAliasAccess(),
            value,
            *this);
 
        return *this;
    }
 
    ThisType& securityDesc(StrRef value)
    {
        setVariableLengthField(
            securityDescAccess(),
            value,
            *this);
 
        return *this;
    }
 
    ThisType& priceUnit(StrRef value)
    {
        setVariableLengthField(
            priceUnitAccess(),
            value,
            *this);
 
        return *this;
    }
 
    ThisType& stripName(StrRef value)
    {
        setVariableLengthField(
            stripNameAccess(),
            value,
            *this);
 
        return *this;
    }
 
    ThisType& hubName(StrRef value)
    {
        setVariableLengthField(
            hubNameAccess(),
            value,
            *this);
 
        return *this;
    }
 
    ThisType& hubAlias(StrRef value)
    {
        setVariableLengthField(
            hubAliasAccess(),
            value,
            *this);
 
        return *this;
    }
 
    ThisType& securityExchange(StrRef value)
    {
        setVariableLengthField(
            securityExchangeAccess(),
            value,
            *this);
 
        return *this;
    }
 
    ThisType& physicalCode(StrRef value)
    {
        setVariableLengthField(
            physicalCodeAccess(),
            value,
            *this);
 
        return *this;
    }
 
    ThisType& homeExchange(StrRef value)
    {
        setVariableLengthField(
            homeExchangeAccess(),
            value,
            *this);
 
        return *this;
    }

    constexpr
    static BlockLength minimalBlockLength(ONIXS_ICEBOE_UNUSED SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            237;
    }

    constexpr
    static BlockLength blockLength(SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            minimalBlockLength(version);
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static MessageSize getMinimalVariableFieldsSize(ONIXS_ICEBOE_UNUSED SchemaVersion version)
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            static_cast<MessageSize>(VarString16::Size) + static_cast<MessageSize>(VarString16::Size) + static_cast<MessageSize>(VarString16::Size) + static_cast<MessageSize>(VarString16::Size) + static_cast<MessageSize>(VarString16::Size) + static_cast<MessageSize>(VarString16::Size) + static_cast<MessageSize>(VarString16::Size) + static_cast<MessageSize>(VarString16::Size) + static_cast<MessageSize>(VarString16::Size) + static_cast<MessageSize>(VarString16::Size) + static_cast<MessageSize>(VarString16::Size) + static_cast<MessageSize>(VarString16::Size) + static_cast<MessageSize>(BlockDetails::EmptySize) + static_cast<MessageSize>(SecurityAltID::EmptySize);
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static UInt64 getMaxMessageSize(UInt8) noexcept
    {
        return
            SbeMessage::getMaxMessageSize();
    }

    ThisType& resetVariableFields() noexcept
    {
        blockDetails(nullOpt);
        securityAltId(nullOpt);
        securityId(nullOpt);
        unitOfMeasure(nullOpt);
        priceDenomination(nullOpt);
        clearedAlias(nullOpt);
        securityDesc(nullOpt);
        priceUnit(nullOpt);
        stripName(nullOpt);
        hubName(nullOpt);
        hubAlias(nullOpt);
        securityExchange(nullOpt);
        physicalCode(nullOpt);
        homeExchange(nullOpt);
        return *this;
    }

    ThisType& reset() noexcept
    {
        securitySubType(nullOpt);
        maturityDate(nullOpt);
        screenLastTradeDate(nullOpt);
        startDate(nullOpt);
        endDate(nullOpt);
        putOrCall(nullOpt);
        strikePrice(nullOpt);
        currency(nullOpt);
        strikeExerciseStyle(nullOpt);
        baseNumLots(nullOpt);
        hedgeProductId(nullOpt);
        hedgeMarketId(nullOpt);
        hedgeOnly(nullOpt);
        isDividendAdjusted(nullOpt);
        impliedType(nullOpt);
        numOfDecimalStrikePrice(nullOpt);
        blockOnly(nullOpt);
        flexAllowed(nullOpt);
        gtAllowed(nullOpt);
        aonAllowed(nullOpt);
        mifidRegulatedMarket(nullOpt);
        flexStrikeAllowed(nullOpt);
        overrideBlockMin(nullOpt);
        testMarketIndicator(nullOpt);
        refSprdProductId(nullOpt);
        marketTransparencyType(nullOpt);
        nCommoditizedMarket(nullOpt);
 
        resetVariableFields();
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef className() noexcept
    {
        return constructStrRef("SecurityDefinitionReport");
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef fixType() noexcept
    {
        return constructStrRef("d");
    }

    ONIXS_ICEBOE_NODISCARD
    std::string toString() const;

    ONIXS_ICEBOE_NODISCARD
    const void* tail() const noexcept
    {
        return
            toOpaquePtr(
                (homeExchange().end()));
    }

    ONIXS_ICEBOE_NODISCARD
    EncodedLength calculateBinarySize() const noexcept
    {
        return
            SbeMessage::calculateBinarySize(tail());
    }
 
private:
    void checkLength(
        EncodedLength length, SchemaVersion version) const
    {
       const EncodedLength minimalRequiredLength =
           minimalBlockLength(version) +
           MessageHeader::Size +
           getMinimalVariableFieldsSize(version);
 
       checkBinaryLength(
           *this, length, minimalRequiredLength);
    }

    void checkVarLenFields() const
    {
        groups().
            tail<BlockDetails>().
            checkVariableLengthFields<SecurityAltID>().
            checkTail<VarString16>().
            checkTail<VarString16>().
            checkTail<VarString16>().
            checkTail<VarString16>().
            checkTail<VarString16>().
            checkTail<VarString16>().
            checkTail<VarString16>().
            checkTail<VarString16>().
            checkTail<VarString16>().
            checkTail<VarString16>().
            checkTail<VarString16>().
            checkTail<VarString16>();
    }
 
    void checkCompatibility() const
    {
        assert(TemplateId == templateId());
 
        checkSchema<Schema>(schemaId(), version());
        checkLength(bufferSize(), version());
        checkVarLenFields();
    }

    struct BlockDetailsAccess
    {
        BlockDetails operator()(const SecurityDefinitionReport& obj) const noexcept
        {
            return obj.
                groups().
                    head<BlockDetails>();
        }
    };

    void blockDetails(NullOpt) noexcept
    {
        resetGroup<BlockDetails>(
            BlockDetailsAccess(),
            *this);
    }

    struct SecurityAltIDAccess
    {
        SecurityAltID operator()(const SecurityDefinitionReport& obj) const noexcept
        {
            return obj.
                groups().
                    tail<BlockDetails>().
                    head<SecurityAltID>();
        }
    };

    void securityAltId(NullOpt) noexcept
    {
        resetGroup<SecurityAltID>(
            SecurityAltIDAccess(),
            *this);
    }

    struct securityIDAccess
    {
        VarString16& operator()(const SecurityDefinitionReport& obj) const noexcept
        {
            return obj.
                groups().
                    tail<BlockDetails>().
                    variableLengthFields<SecurityAltID>().
                    head<VarString16>();
        }
    };

    struct unitOfMeasureAccess
    {
        VarString16& operator()(const SecurityDefinitionReport& obj) const noexcept
        {
            return obj.
                groups().
                    tail<BlockDetails>().
                    variableLengthFields<SecurityAltID>().
                    tail<VarString16>().
                    head<VarString16>();
        }
    };

    struct priceDenominationAccess
    {
        VarString16& operator()(const SecurityDefinitionReport& obj) const noexcept
        {
            return obj.
                groups().
                    tail<BlockDetails>().
                    variableLengthFields<SecurityAltID>().
                    tail<VarString16>().
                    tail<VarString16>().
                    head<VarString16>();
        }
    };

    struct clearedAliasAccess
    {
        VarString16& operator()(const SecurityDefinitionReport& obj) const noexcept
        {
            return obj.
                groups().
                    tail<BlockDetails>().
                    variableLengthFields<SecurityAltID>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    head<VarString16>();
        }
    };

    struct securityDescAccess
    {
        VarString16& operator()(const SecurityDefinitionReport& obj) const noexcept
        {
            return obj.
                groups().
                    tail<BlockDetails>().
                    variableLengthFields<SecurityAltID>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    head<VarString16>();
        }
    };

    struct priceUnitAccess
    {
        VarString16& operator()(const SecurityDefinitionReport& obj) const noexcept
        {
            return obj.
                groups().
                    tail<BlockDetails>().
                    variableLengthFields<SecurityAltID>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    head<VarString16>();
        }
    };

    struct stripNameAccess
    {
        VarString16& operator()(const SecurityDefinitionReport& obj) const noexcept
        {
            return obj.
                groups().
                    tail<BlockDetails>().
                    variableLengthFields<SecurityAltID>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    head<VarString16>();
        }
    };

    struct hubNameAccess
    {
        VarString16& operator()(const SecurityDefinitionReport& obj) const noexcept
        {
            return obj.
                groups().
                    tail<BlockDetails>().
                    variableLengthFields<SecurityAltID>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    head<VarString16>();
        }
    };

    struct hubAliasAccess
    {
        VarString16& operator()(const SecurityDefinitionReport& obj) const noexcept
        {
            return obj.
                groups().
                    tail<BlockDetails>().
                    variableLengthFields<SecurityAltID>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    head<VarString16>();
        }
    };

    struct securityExchangeAccess
    {
        VarString16& operator()(const SecurityDefinitionReport& obj) const noexcept
        {
            return obj.
                groups().
                    tail<BlockDetails>().
                    variableLengthFields<SecurityAltID>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    head<VarString16>();
        }
    };

    struct physicalCodeAccess
    {
        VarString16& operator()(const SecurityDefinitionReport& obj) const noexcept
        {
            return obj.
                groups().
                    tail<BlockDetails>().
                    variableLengthFields<SecurityAltID>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    head<VarString16>();
        }
    };

    struct homeExchangeAccess
    {
        VarString16& operator()(const SecurityDefinitionReport& obj) const noexcept
        {
            return obj.
                groups().
                    tail<BlockDetails>().
                    variableLengthFields<SecurityAltID>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    tail<VarString16>().
                    head<VarString16>();
        }
    };

    ThisType& securityId(NullOpt) noexcept
    {
        setVariableLengthFieldToNull(
            securityIDAccess(),
            *this);
 
        return *this;
    }

    ThisType& unitOfMeasure(NullOpt) noexcept
    {
        setVariableLengthFieldToNull(
            unitOfMeasureAccess(),
            *this);
 
        return *this;
    }

    ThisType& priceDenomination(NullOpt) noexcept
    {
        setVariableLengthFieldToNull(
            priceDenominationAccess(),
            *this);
 
        return *this;
    }

    ThisType& clearedAlias(NullOpt) noexcept
    {
        setVariableLengthFieldToNull(
            clearedAliasAccess(),
            *this);
 
        return *this;
    }

    ThisType& securityDesc(NullOpt) noexcept
    {
        setVariableLengthFieldToNull(
            securityDescAccess(),
            *this);
 
        return *this;
    }

    ThisType& priceUnit(NullOpt) noexcept
    {
        setVariableLengthFieldToNull(priceUnitAccess(), *this);
 
        return *this;
    }

    ThisType& stripName(NullOpt) noexcept
    {
        setVariableLengthFieldToNull(stripNameAccess(), *this);
 
        return *this;
    }

    ThisType& hubName(NullOpt) noexcept
    {
        setVariableLengthFieldToNull(hubNameAccess(), *this);
 
        return *this;
    }

    ThisType& hubAlias(NullOpt) noexcept
    {
        setVariableLengthFieldToNull(hubAliasAccess(), *this);
 
        return *this;
    }

    ThisType& securityExchange(NullOpt) noexcept
    {
        setVariableLengthFieldToNull(
            securityExchangeAccess(),
            *this);
 
        return *this;
    }

    ThisType& physicalCode(NullOpt) noexcept
    {
        setVariableLengthFieldToNull(
            physicalCodeAccess(),
            *this);
 
        return *this;
    }

    ThisType& homeExchange(NullOpt) noexcept
    {
        setVariableLengthFieldToNull(
            homeExchangeAccess(),
            *this);
 
        return *this;
    }
};

struct
SecurityDefinitionReject
: SbeMessage
{
    typedef SchemaTraits Schema;

    typedef SecurityDefinitionReject ThisType;

    enum { TemplateId = 155 };

    SecurityDefinitionReject() = default;

    SecurityDefinitionReject(void* data, EncodedLength length, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        reset();
    }

    SecurityDefinitionReject(void* data, EncodedLength length, NoFieldsInit, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        resetVariableFields();
    }

    SecurityDefinitionReject(void* data, EncodedLength length, NoInit)
      : SbeMessage(data, length)
    {
        checkCompatibility();
    }

    explicit
    SecurityDefinitionReject(const SbeMessage& message)
      : SbeMessage(message)
    {
        assert(message.valid());
 
        checkCompatibility();
    }

    SecurityDefinitionReject(void* data, EncodedLength length, NoInit, NoCheck) noexcept
      : SbeMessage(data, length, NoCheck())
    {
        assert(schemaId() == Schema::Id);
        assert(version() >= Schema::MinimalVersion);
        assert(TemplateId == templateId());
    }

    ONIXS_ICEBOE_NODISCARD
    auto securityReqId() const noexcept
    {
        constexpr BlockLength offset = 0;
 
        return ordinary<Int32>(offset);
    }

    ThisType& securityReqId(Int32 value) noexcept
    {
        constexpr BlockLength offset = 0;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto securityResponseType() const noexcept
    {
        constexpr BlockLength offset = 4;
 
        return enumeration<SecurityResponseTypeEnum>(offset);
    }

    ThisType& securityResponseType(SecurityResponseTypeEnum value) noexcept
    {
        constexpr BlockLength offset = 4;
 
        setEnumeration<SecurityResponseTypeEnum>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto securityRequestType() const noexcept
    {
        constexpr BlockLength offset = 5;
 
        return enumeration<SecurityRequestTypeEnum>(offset);
    }

    ThisType& securityRequestType(SecurityRequestTypeEnum value) noexcept
    {
        constexpr BlockLength offset = 5;
 
        setEnumeration<SecurityRequestTypeEnum>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto marketTypeId() const noexcept
    {
        constexpr BlockLength offset = 6;
 
        return ordinary<Int32>(offset);
    }

    ThisType& marketTypeId(Int32 value) noexcept
    {
        constexpr BlockLength offset = 6;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto securityType() const noexcept
    {
        constexpr BlockLength offset = 10;
 
        return enumeration<SecurityTypeEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& securityType(SecurityTypeEnum value) noexcept
    {
        constexpr BlockLength offset = 10;
 
        setEnumeration<SecurityTypeEnum>(offset, value);
        return *this;
    }
 
    ThisType& securityType(NullOpt) noexcept
    {
        constexpr BlockLength offset = 10;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto exchangeCode() const noexcept
    {
        constexpr BlockLength offset = 11;
 
        return ordinary<NullInt32NULL>(offset, optional);
    }

    ThisType& exchangeCode(Int32NULL value) noexcept
    {
        constexpr BlockLength offset = 11;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& exchangeCode(NullOpt) noexcept
    {
        constexpr BlockLength offset = 11;
 
        setOrdinary(offset, NullInt32NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto text() const noexcept
    {
        constexpr BlockLength offset = 15;
        constexpr BlockLength length = 100;
 
        return fixedStr<length>(offset, optional);
    }

    ThisType& text(StrRef value) noexcept
    {
        constexpr BlockLength offset = 15;
        constexpr BlockLength length = 100;
 
        setFixedStr<length>(offset, value);
        return *this;
    }
 
    ThisType& text(NullOpt) noexcept
    {
        constexpr BlockLength offset = 15;
        constexpr BlockLength length = 100;
 
        setFixedStr<length>(offset, StrRef());
        return *this;
    }

    constexpr
    static BlockLength minimalBlockLength(ONIXS_ICEBOE_UNUSED SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            115;
    }

    constexpr
    static BlockLength blockLength(SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            minimalBlockLength(version);
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static MessageSize getMinimalVariableFieldsSize(ONIXS_ICEBOE_UNUSED SchemaVersion version)
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            0;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static UInt64 getMaxMessageSize(UInt8) noexcept
    {
        return
            static_cast<UInt64>(MessageHeaderBuilder::Size) +
            blockLength(Schema::Version);
    }

    ThisType& resetVariableFields() noexcept
    {
        return *this;
    }

    ThisType& reset() noexcept
    {
        securityType(nullOpt);
        exchangeCode(nullOpt);
        text(nullOpt);
 
        resetVariableFields();
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef className() noexcept
    {
        return constructStrRef("SecurityDefinitionReject");
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef fixType() noexcept
    {
        return constructStrRef("d");
    }

    ONIXS_ICEBOE_NODISCARD
    std::string toString() const;

    ONIXS_ICEBOE_NODISCARD
    const void* tail() const noexcept
    {
        return
            toOpaquePtr(
                advanceByBytes(
                    binary(),
                    static_cast<ptrdiff_t>(SbeMessage::blockLength()) +
                        MessageHeader::Size));
    }

    ONIXS_ICEBOE_NODISCARD
    EncodedLength calculateBinarySize() const noexcept
    {
        return
            SbeMessage::calculateBinarySize(tail());
    }
 
private:
    void checkLength(
        EncodedLength length, SchemaVersion version) const
    {
       const EncodedLength minimalRequiredLength =
           minimalBlockLength(version) +
           MessageHeader::Size +
           getMinimalVariableFieldsSize(version);
 
       checkBinaryLength(
           *this, length, minimalRequiredLength);
    }
 
    void checkCompatibility() const
    {
        assert(TemplateId == templateId());
 
        checkSchema<Schema>(schemaId(), version());
        checkLength(bufferSize(), version());
    }
};

struct
SecurityDefinitionRequest
: SbeMessage
{
    typedef SchemaTraits Schema;

    typedef SecurityDefinitionRequest ThisType;

    enum { TemplateId = 15 };

    SecurityDefinitionRequest() = default;

    SecurityDefinitionRequest(void* data, EncodedLength length, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        reset();
    }

    SecurityDefinitionRequest(void* data, EncodedLength length, NoFieldsInit, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        resetVariableFields();
    }

    SecurityDefinitionRequest(void* data, EncodedLength length, NoInit)
      : SbeMessage(data, length)
    {
        checkCompatibility();
    }

    explicit
    SecurityDefinitionRequest(const SbeMessage& message)
      : SbeMessage(message)
    {
        assert(message.valid());
 
        checkCompatibility();
    }

    SecurityDefinitionRequest(void* data, EncodedLength length, NoInit, NoCheck) noexcept
      : SbeMessage(data, length, NoCheck())
    {
        assert(schemaId() == Schema::Id);
        assert(version() >= Schema::MinimalVersion);
        assert(TemplateId == templateId());
    }

    ONIXS_ICEBOE_NODISCARD
    auto securityReqId() const noexcept
    {
        constexpr BlockLength offset = 0;
 
        return ordinary<Int32>(offset);
    }

    ThisType& securityReqId(Int32 value) noexcept
    {
        constexpr BlockLength offset = 0;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto securityRequestType() const noexcept
    {
        constexpr BlockLength offset = 4;
 
        return enumeration<SecurityRequestTypeEnum>(offset);
    }

    ThisType& securityRequestType(SecurityRequestTypeEnum value) noexcept
    {
        constexpr BlockLength offset = 4;
 
        setEnumeration<SecurityRequestTypeEnum>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto marketTypeId() const noexcept
    {
        constexpr BlockLength offset = 5;
 
        return ordinary<Int32>(offset);
    }

    ThisType& marketTypeId(Int32 value) noexcept
    {
        constexpr BlockLength offset = 5;
 
        setOrdinary(offset, value);
        return *this;
    }

    constexpr
    static BlockLength minimalBlockLength(ONIXS_ICEBOE_UNUSED SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            9;
    }

    constexpr
    static BlockLength blockLength(SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            minimalBlockLength(version);
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static MessageSize getMinimalVariableFieldsSize(ONIXS_ICEBOE_UNUSED SchemaVersion version)
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            0;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static UInt64 getMaxMessageSize(UInt8) noexcept
    {
        return
            static_cast<UInt64>(MessageHeaderBuilder::Size) +
            blockLength(Schema::Version);
    }

    ThisType& resetVariableFields() noexcept
    {
        return *this;
    }

    ThisType& reset() noexcept
    {
        resetVariableFields();
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef className() noexcept
    {
        return constructStrRef("SecurityDefinitionRequest");
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef fixType() noexcept
    {
        return constructStrRef("c");
    }

    ONIXS_ICEBOE_NODISCARD
    std::string toString() const;

    ONIXS_ICEBOE_NODISCARD
    const void* tail() const noexcept
    {
        return
            toOpaquePtr(
                advanceByBytes(
                    binary(),
                    static_cast<ptrdiff_t>(SbeMessage::blockLength()) +
                        MessageHeader::Size));
    }

    ONIXS_ICEBOE_NODISCARD
    EncodedLength calculateBinarySize() const noexcept
    {
        return
            SbeMessage::calculateBinarySize(tail());
    }
 
private:
    void checkLength(
        EncodedLength length, SchemaVersion version) const
    {
       const EncodedLength minimalRequiredLength =
           minimalBlockLength(version) +
           MessageHeader::Size +
           getMinimalVariableFieldsSize(version);
 
       checkBinaryLength(
           *this, length, minimalRequiredLength);
    }
 
    void checkCompatibility() const
    {
        assert(TemplateId == templateId());
 
        checkSchema<Schema>(schemaId(), version());
        checkLength(bufferSize(), version());
    }
};

struct
SecurityDefinitionReport_Product
: SbeMessage
{
    typedef SchemaTraits Schema;

    typedef SecurityDefinitionReport_Product ThisType;

    enum { TemplateId = 154 };

    SecurityDefinitionReport_Product() = default;

    SecurityDefinitionReport_Product(void* data, EncodedLength length, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        reset();
    }

    SecurityDefinitionReport_Product(void* data, EncodedLength length, NoFieldsInit, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        resetVariableFields();
    }

    SecurityDefinitionReport_Product(void* data, EncodedLength length, NoInit)
      : SbeMessage(data, length)
    {
        checkCompatibility();
    }

    explicit
    SecurityDefinitionReport_Product(const SbeMessage& message)
      : SbeMessage(message)
    {
        assert(message.valid());
 
        checkCompatibility();
    }

    SecurityDefinitionReport_Product(void* data, EncodedLength length, NoInit, NoCheck) noexcept
      : SbeMessage(data, length, NoCheck())
    {
        assert(schemaId() == Schema::Id);
        assert(version() >= Schema::MinimalVersion);
        assert(TemplateId == templateId());
    }

    ONIXS_ICEBOE_NODISCARD
    auto securityReqId() const noexcept
    {
        constexpr BlockLength offset = 0;
 
        return ordinary<Int32>(offset);
    }

    ThisType& securityReqId(Int32 value) noexcept
    {
        constexpr BlockLength offset = 0;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto securityResponseType() const noexcept
    {
        constexpr BlockLength offset = 4;
 
        return enumeration<SecurityResponseTypeEnum>(offset);
    }

    ThisType& securityResponseType(SecurityResponseTypeEnum value) noexcept
    {
        constexpr BlockLength offset = 4;
 
        setEnumeration<SecurityResponseTypeEnum>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto securityResponseId() const noexcept
    {
        constexpr BlockLength offset = 5;
 
        return ordinary<Int32>(offset);
    }

    ThisType& securityResponseId(Int32 value) noexcept
    {
        constexpr BlockLength offset = 5;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto marketTypeId() const noexcept
    {
        constexpr BlockLength offset = 9;
 
        return ordinary<Int32>(offset);
    }

    ThisType& marketTypeId(Int32 value) noexcept
    {
        constexpr BlockLength offset = 9;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto rpts() const noexcept
    {
        constexpr BlockLength offset = 13;
 
        return ordinary<Int32>(offset);
    }

    ThisType& rpts(Int32 value) noexcept
    {
        constexpr BlockLength offset = 13;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto listSeqNo() const noexcept
    {
        constexpr BlockLength offset = 17;
 
        return ordinary<Int32>(offset);
    }

    ThisType& listSeqNo(Int32 value) noexcept
    {
        constexpr BlockLength offset = 17;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto productId() const noexcept
    {
        constexpr BlockLength offset = 21;
 
        return ordinary<Int32>(offset);
    }

    ThisType& productId(Int32 value) noexcept
    {
        constexpr BlockLength offset = 21;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto productType() const noexcept
    {
        constexpr BlockLength offset = 25;
        constexpr BlockLength length = 12;
 
        return fixedStr<length>(offset, optional);
    }

    ThisType& productType(StrRef value) noexcept
    {
        constexpr BlockLength offset = 25;
        constexpr BlockLength length = 12;
 
        setFixedStr<length>(offset, value);
        return *this;
    }
 
    ThisType& productType(NullOpt) noexcept
    {
        constexpr BlockLength offset = 25;
        constexpr BlockLength length = 12;
 
        setFixedStr<length>(offset, StrRef());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto mifidRegulatedMarket() const noexcept
    {
        constexpr BlockLength offset = 37;
 
        return enumeration<BooleanEnum>(offset);
    }

    ThisType& mifidRegulatedMarket(BooleanEnum value) noexcept
    {
        constexpr BlockLength offset = 37;
 
        setEnumeration<BooleanEnum>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto testMarketIndicator() const noexcept
    {
        constexpr BlockLength offset = 38;
 
        return enumeration<BooleanEnum>(offset);
    }

    ThisType& testMarketIndicator(BooleanEnum value) noexcept
    {
        constexpr BlockLength offset = 38;
 
        setEnumeration<BooleanEnum>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto stopsAllowed() const noexcept
    {
        constexpr BlockLength offset = 39;
 
        return enumeration<BooleanEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& stopsAllowed(BooleanEnum value) noexcept
    {
        constexpr BlockLength offset = 39;
 
        setEnumeration<BooleanEnum>(offset, value);
        return *this;
    }
 
    ThisType& stopsAllowed(NullOpt) noexcept
    {
        constexpr BlockLength offset = 39;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto optionsAllowed() const noexcept
    {
        constexpr BlockLength offset = 40;
 
        return enumeration<BooleanEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& optionsAllowed(BooleanEnum value) noexcept
    {
        constexpr BlockLength offset = 40;
 
        setEnumeration<BooleanEnum>(offset, value);
        return *this;
    }
 
    ThisType& optionsAllowed(NullOpt) noexcept
    {
        constexpr BlockLength offset = 40;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto udsOptionsAllowed() const noexcept
    {
        constexpr BlockLength offset = 41;
 
        return enumeration<BooleanEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& udsOptionsAllowed(BooleanEnum value) noexcept
    {
        constexpr BlockLength offset = 41;
 
        setEnumeration<BooleanEnum>(offset, value);
        return *this;
    }
 
    ThisType& udsOptionsAllowed(NullOpt) noexcept
    {
        constexpr BlockLength offset = 41;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto udsFuturesAllowed() const noexcept
    {
        constexpr BlockLength offset = 42;
 
        return enumeration<BooleanEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& udsFuturesAllowed(BooleanEnum value) noexcept
    {
        constexpr BlockLength offset = 42;
 
        setEnumeration<BooleanEnum>(offset, value);
        return *this;
    }
 
    ThisType& udsFuturesAllowed(NullOpt) noexcept
    {
        constexpr BlockLength offset = 42;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto massQuotesAllowed() const noexcept
    {
        constexpr BlockLength offset = 43;
 
        return enumeration<BooleanEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& massQuotesAllowed(BooleanEnum value) noexcept
    {
        constexpr BlockLength offset = 43;
 
        setEnumeration<BooleanEnum>(offset, value);
        return *this;
    }
 
    ThisType& massQuotesAllowed(NullOpt) noexcept
    {
        constexpr BlockLength offset = 43;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto rfqFuturesAllowed() const noexcept
    {
        constexpr BlockLength offset = 44;
 
        return enumeration<BooleanEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& rfqFuturesAllowed(BooleanEnum value) noexcept
    {
        constexpr BlockLength offset = 44;
 
        setEnumeration<BooleanEnum>(offset, value);
        return *this;
    }
 
    ThisType& rfqFuturesAllowed(NullOpt) noexcept
    {
        constexpr BlockLength offset = 44;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto rfqOptionsAllowed() const noexcept
    {
        constexpr BlockLength offset = 45;
 
        return enumeration<BooleanEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& rfqOptionsAllowed(BooleanEnum value) noexcept
    {
        constexpr BlockLength offset = 45;
 
        setEnumeration<BooleanEnum>(offset, value);
        return *this;
    }
 
    ThisType& rfqOptionsAllowed(NullOpt) noexcept
    {
        constexpr BlockLength offset = 45;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto crossingOrderFuturesAllowed() const noexcept
    {
        constexpr BlockLength offset = 46;
 
        return enumeration<BooleanEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& crossingOrderFuturesAllowed(BooleanEnum value) noexcept
    {
        constexpr BlockLength offset = 46;
 
        setEnumeration<BooleanEnum>(offset, value);
        return *this;
    }
 
    ThisType& crossingOrderFuturesAllowed(NullOpt) noexcept
    {
        constexpr BlockLength offset = 46;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto crossingOrderOptionsAllowed() const noexcept
    {
        constexpr BlockLength offset = 47;
 
        return enumeration<BooleanEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& crossingOrderOptionsAllowed(BooleanEnum value) noexcept
    {
        constexpr BlockLength offset = 47;
 
        setEnumeration<BooleanEnum>(offset, value);
        return *this;
    }
 
    ThisType& crossingOrderOptionsAllowed(NullOpt) noexcept
    {
        constexpr BlockLength offset = 47;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto selfBlockAllowed() const noexcept
    {
        constexpr BlockLength offset = 48;
 
        return enumeration<BooleanEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& selfBlockAllowed(BooleanEnum value) noexcept
    {
        constexpr BlockLength offset = 48;
 
        setEnumeration<BooleanEnum>(offset, value);
        return *this;
    }
 
    ThisType& selfBlockAllowed(NullOpt) noexcept
    {
        constexpr BlockLength offset = 48;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }
 
    ONIXS_ICEBOE_NODISCARD
    StrRef productName() const noexcept
    {
        return getVariableLengthField(
            productNameAccess(),
            *this);
    }
 
    ONIXS_ICEBOE_NODISCARD
    StrRef productDesc() const noexcept
    {
        return getVariableLengthField(
            productDescAccess(),
            *this);
    }
 
    ONIXS_ICEBOE_NODISCARD
    StrRef productGroup() const noexcept
    {
        return getVariableLengthField(
            productGroupAccess(),
            *this);
    }
 
    ThisType& productName(StrRef value)
    {
        setVariableLengthField(
            productNameAccess(),
            value,
            *this);
 
        return *this;
    }
 
    ThisType& productDesc(StrRef value)
    {
        setVariableLengthField(
            productDescAccess(),
            value,
            *this);
 
        return *this;
    }
 
    ThisType& productGroup(StrRef value)
    {
        setVariableLengthField(
            productGroupAccess(),
            value,
            *this);
 
        return *this;
    }

    constexpr
    static BlockLength minimalBlockLength(ONIXS_ICEBOE_UNUSED SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            49;
    }

    constexpr
    static BlockLength blockLength(SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            minimalBlockLength(version);
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static MessageSize getMinimalVariableFieldsSize(ONIXS_ICEBOE_UNUSED SchemaVersion version)
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            static_cast<MessageSize>(VarString16::Size) + static_cast<MessageSize>(VarString16::Size) + static_cast<MessageSize>(VarString16::Size);
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static UInt64 getMaxMessageSize(UInt8) noexcept
    {
        return
            SbeMessage::getMaxMessageSize();
    }

    ThisType& resetVariableFields() noexcept
    {
        productName(nullOpt);
        productDesc(nullOpt);
        productGroup(nullOpt);
        return *this;
    }

    ThisType& reset() noexcept
    {
        productType(nullOpt);
        stopsAllowed(nullOpt);
        optionsAllowed(nullOpt);
        udsOptionsAllowed(nullOpt);
        udsFuturesAllowed(nullOpt);
        massQuotesAllowed(nullOpt);
        rfqFuturesAllowed(nullOpt);
        rfqOptionsAllowed(nullOpt);
        crossingOrderFuturesAllowed(nullOpt);
        crossingOrderOptionsAllowed(nullOpt);
        selfBlockAllowed(nullOpt);
 
        resetVariableFields();
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef className() noexcept
    {
        return constructStrRef("SecurityDefinitionReport_Product");
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef fixType() noexcept
    {
        return constructStrRef(
            "SecurityDefinitionReport_Product");
    }

    ONIXS_ICEBOE_NODISCARD
    std::string toString() const;

    ONIXS_ICEBOE_NODISCARD
    const void* tail() const noexcept
    {
        return
            toOpaquePtr(
                (productGroup().end()));
    }

    ONIXS_ICEBOE_NODISCARD
    EncodedLength calculateBinarySize() const noexcept
    {
        return
            SbeMessage::calculateBinarySize(tail());
    }
 
private:
    void checkLength(
        EncodedLength length, SchemaVersion version) const
    {
       const EncodedLength minimalRequiredLength =
           minimalBlockLength(version) +
           MessageHeader::Size +
           getMinimalVariableFieldsSize(version);
 
       checkBinaryLength(
           *this, length, minimalRequiredLength);
    }

    void checkVarLenFields() const
    {
        variableLengthFields().
            checkTail<VarString16>().
            checkTail<VarString16>().
            checkTail<VarString16>();
    }
 
    void checkCompatibility() const
    {
        assert(TemplateId == templateId());
 
        checkSchema<Schema>(schemaId(), version());
        checkLength(bufferSize(), version());
        checkVarLenFields();
    }

    struct productNameAccess
    {
        VarString16& operator()(const SecurityDefinitionReport_Product& obj) const noexcept
        {
            return obj.
                variableLengthFields().
                    head<VarString16>();
        }
    };

    struct productDescAccess
    {
        VarString16& operator()(const SecurityDefinitionReport_Product& obj) const noexcept
        {
            return obj.
                variableLengthFields().
                    tail<VarString16>().
                    head<VarString16>();
        }
    };

    struct productGroupAccess
    {
        VarString16& operator()(const SecurityDefinitionReport_Product& obj) const noexcept
        {
            return obj.
                variableLengthFields().
                    tail<VarString16>().
                    tail<VarString16>().
                    head<VarString16>();
        }
    };

    ThisType& productName(NullOpt) noexcept
    {
        setVariableLengthFieldToNull(
            productNameAccess(),
            *this);
 
        return *this;
    }

    ThisType& productDesc(NullOpt) noexcept
    {
        setVariableLengthFieldToNull(
            productDescAccess(),
            *this);
 
        return *this;
    }

    ThisType& productGroup(NullOpt) noexcept
    {
        setVariableLengthFieldToNull(
            productGroupAccess(),
            *this);
 
        return *this;
    }
};

struct
IPRequest
: SbeMessage
{
    typedef SchemaTraits Schema;

    typedef IPRequest ThisType;

    enum { TemplateId = 2001 };

    struct
    UsersEntry : SbeGroupEntry
    <
        GroupSizeEncoding::BlockLength
    >
    {
        typedef
        SbeGroupEntry
        <
            GroupSizeEncoding::BlockLength
        >
        Base;

        typedef UsersEntry ThisType;

        UsersEntry(void* data, EncodedLength length, SchemaVersion version)
          : Base(data, numericCast<Base::BlockLength>(length), version)
        {
            assert(version >= Schema::MinimalVersion);
            assert(length >= minimalBlockLength(version));
        }

        ThisType& resetVariableFields() noexcept
        {
            return *this;
        }

        ThisType& reset() noexcept
        {
            resetVariableFields();
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto userId() const noexcept
        {
            constexpr BlockLength offset = 0;
            constexpr BlockLength length = 20;
 
            return fixedStr<length>(offset);
        }

        ThisType& userId(StrRef value) noexcept
        {
            constexpr BlockLength offset = 0;
            constexpr BlockLength length = 20;
 
            setFixedStr<length>(offset, value);
            return *this;
        }

        constexpr
        static BlockLength blockLength(SchemaVersion version) noexcept
        {
            return
                ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
                minimalBlockLength(version);
        }

        constexpr
        static BlockLength minimalBlockLength(ONIXS_ICEBOE_UNUSED SchemaVersion version) noexcept
        {
            return
                ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
                20;
        }

        ONIXS_ICEBOE_NODISCARD
        constexpr
        static StrRef className() noexcept
        {
            return constructStrRef("IPRequest.UsersEntry");
        }
    };

    typedef
    SbeGroup<UsersEntry, GroupSizeEncoding, MessageSize>
    Users;

    IPRequest() = default;

    IPRequest(void* data, EncodedLength length, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        reset();
    }

    IPRequest(void* data, EncodedLength length, NoFieldsInit, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        resetVariableFields();
    }

    IPRequest(void* data, EncodedLength length, NoInit)
      : SbeMessage(data, length)
    {
        checkCompatibility();
    }

    explicit
    IPRequest(const SbeMessage& message)
      : SbeMessage(message)
    {
        assert(message.valid());
 
        checkCompatibility();
    }

    IPRequest(void* data, EncodedLength length, NoInit, NoCheck) noexcept
      : SbeMessage(data, length, NoCheck())
    {
        assert(schemaId() == Schema::Id);
        assert(version() >= Schema::MinimalVersion);
        assert(TemplateId == templateId());
    }

    ONIXS_ICEBOE_NODISCARD
    auto clientId() const noexcept
    {
        constexpr BlockLength offset = 0;
 
        return ordinary<Int32>(offset);
    }

    ThisType& clientId(Int32 value) noexcept
    {
        constexpr BlockLength offset = 0;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    Users users() const noexcept
    {
        return getGroup<Users>(UsersAccess(), *this);
    }

    ONIXS_ICEBOE_NODISCARD
    Users users() noexcept
    {
        return getGroup<Users>(UsersAccess(), *this);
    }

    Users users(Users::Size length)
    {
        return constructGroup<Users>(
            UsersAccess(),
            length,
            *this);
    }

    Users users(Users::Size length, NoFieldsInit)
    {
        return setupGroup<Users>(
            UsersAccess(),
            length,
            *this);
    }

    constexpr
    static BlockLength minimalBlockLength(ONIXS_ICEBOE_UNUSED SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            4;
    }

    constexpr
    static BlockLength blockLength(SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            minimalBlockLength(version);
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static MessageSize getMinimalVariableFieldsSize(ONIXS_ICEBOE_UNUSED SchemaVersion version)
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            static_cast<MessageSize>(Users::EmptySize);
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static UInt64 getMaxMessageSize(UInt8 maxGroupItems = 255) noexcept
    {
        return
            static_cast<UInt64>(MessageHeaderBuilder::Size) +
            blockLength(Schema::Version) +
            (GroupSizeEncoding::Size + UsersEntry::blockLength(Schema::Version) * static_cast<UInt64>(maxGroupItems));
    }

    ThisType& resetVariableFields() noexcept
    {
        users(nullOpt);
        return *this;
    }

    ThisType& reset() noexcept
    {
        resetVariableFields();
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef className() noexcept
    {
        return constructStrRef("IPRequest");
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef fixType() noexcept
    {
        return constructStrRef("IPRequest");
    }

    ONIXS_ICEBOE_NODISCARD
    std::string toString() const;

    ONIXS_ICEBOE_NODISCARD
    const void* tail() const noexcept
    {
        return
            users().tail();
    }

    ONIXS_ICEBOE_NODISCARD
    EncodedLength calculateBinarySize() const noexcept
    {
        return
            SbeMessage::calculateBinarySize(tail());
    }
 
private:
    void checkLength(
        EncodedLength length, SchemaVersion version) const
    {
       const EncodedLength minimalRequiredLength =
           minimalBlockLength(version) +
           MessageHeader::Size +
           getMinimalVariableFieldsSize(version);
 
       checkBinaryLength(
           *this, length, minimalRequiredLength);
    }

    void checkVarLenFields() const
    {
        groups().
            checkTail<Users>();
    }
 
    void checkCompatibility() const
    {
        assert(TemplateId == templateId());
 
        checkSchema<Schema>(schemaId(), version());
        checkLength(bufferSize(), version());
        checkVarLenFields();
    }

    struct UsersAccess
    {
        Users operator()(const IPRequest& obj) const noexcept
        {
            return obj.
                groups().
                    head<Users>();
        }
    };

    void users(NullOpt) noexcept
    {
        resetGroup<Users>(UsersAccess(), *this);
    }
};

struct
IPReport
: SbeMessage
{
    typedef SchemaTraits Schema;

    typedef IPReport ThisType;

    enum { TemplateId = 2002 };

    struct
    UsersEntry : SbeGroupEntry
    <
        GroupSizeEncoding::BlockLength
    >
    {
        typedef
        SbeGroupEntry
        <
            GroupSizeEncoding::BlockLength
        >
        Base;

        typedef UsersEntry ThisType;

        UsersEntry(void* data, EncodedLength length, SchemaVersion version)
          : Base(data, numericCast<Base::BlockLength>(length), version)
        {
            assert(version >= Schema::MinimalVersion);
            assert(length >= minimalBlockLength(version));
        }

        ThisType& resetVariableFields() noexcept
        {
            return *this;
        }

        ThisType& reset() noexcept
        {
            success(nullOpt);
            ipAddress(nullOpt);
            port(nullOpt);
            ipSessionToken(nullOpt);
 
            resetVariableFields();
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto userId() const noexcept
        {
            constexpr BlockLength offset = 0;
            constexpr BlockLength length = 20;
 
            return fixedStr<length>(offset);
        }

        ThisType& userId(StrRef value) noexcept
        {
            constexpr BlockLength offset = 0;
            constexpr BlockLength length = 20;
 
            setFixedStr<length>(offset, value);
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto success() const noexcept
        {
            constexpr BlockLength offset = 20;
 
            return enumeration<BooleanEnum, NullUint8NULL>(offset, optional);
        }

        ThisType& success(BooleanEnum value) noexcept
        {
            constexpr BlockLength offset = 20;
 
            setEnumeration<BooleanEnum>(offset, value);
            return *this;
        }
 
        ThisType& success(NullOpt) noexcept
        {
            constexpr BlockLength offset = 20;
 
            setOrdinary(offset, NullUint8NULL());
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto ipAddress() const noexcept
        {
            constexpr BlockLength offset = 21;
            constexpr BlockLength length = 15;
 
            return fixedStr<length>(offset, optional);
        }

        ThisType& ipAddress(StrRef value) noexcept
        {
            constexpr BlockLength offset = 21;
            constexpr BlockLength length = 15;
 
            setFixedStr<length>(offset, value);
            return *this;
        }
 
        ThisType& ipAddress(NullOpt) noexcept
        {
            constexpr BlockLength offset = 21;
            constexpr BlockLength length = 15;
 
            setFixedStr<length>(offset, StrRef());
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto port() const noexcept
        {
            constexpr BlockLength offset = 36;
 
            return ordinary<NullInt16NULL>(offset, optional);
        }

        ThisType& port(Int16NULL value) noexcept
        {
            constexpr BlockLength offset = 36;
 
            setOrdinary(offset, value);
            return *this;
        }
 
        ThisType& port(NullOpt) noexcept
        {
            constexpr BlockLength offset = 36;
 
            setOrdinary(offset, NullInt16NULL());
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto ipSessionToken() const noexcept
        {
            constexpr BlockLength offset = 38;
            constexpr BlockLength length = 50;
 
            return fixedStr<length>(offset, optional);
        }

        ThisType& ipSessionToken(StrRef value) noexcept
        {
            constexpr BlockLength offset = 38;
            constexpr BlockLength length = 50;
 
            setFixedStr<length>(offset, value);
            return *this;
        }
 
        ThisType& ipSessionToken(NullOpt) noexcept
        {
            constexpr BlockLength offset = 38;
            constexpr BlockLength length = 50;
 
            setFixedStr<length>(offset, StrRef());
            return *this;
        }

        constexpr
        static BlockLength blockLength(SchemaVersion version) noexcept
        {
            return
                ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
                minimalBlockLength(version);
        }

        constexpr
        static BlockLength minimalBlockLength(ONIXS_ICEBOE_UNUSED SchemaVersion version) noexcept
        {
            return
                ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
                88;
        }

        ONIXS_ICEBOE_NODISCARD
        constexpr
        static StrRef className() noexcept
        {
            return constructStrRef("IPReport.UsersEntry");
        }
    };

    typedef
    SbeGroup<UsersEntry, GroupSizeEncoding, MessageSize>
    Users;

    IPReport() = default;

    IPReport(void* data, EncodedLength length, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        reset();
    }

    IPReport(void* data, EncodedLength length, NoFieldsInit, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        resetVariableFields();
    }

    IPReport(void* data, EncodedLength length, NoInit)
      : SbeMessage(data, length)
    {
        checkCompatibility();
    }

    explicit
    IPReport(const SbeMessage& message)
      : SbeMessage(message)
    {
        assert(message.valid());
 
        checkCompatibility();
    }

    IPReport(void* data, EncodedLength length, NoInit, NoCheck) noexcept
      : SbeMessage(data, length, NoCheck())
    {
        assert(schemaId() == Schema::Id);
        assert(version() >= Schema::MinimalVersion);
        assert(TemplateId == templateId());
    }

    ONIXS_ICEBOE_NODISCARD
    auto exchangeCode() const noexcept
    {
        constexpr BlockLength offset = 0;
 
        return ordinary<NullInt32NULL>(offset, optional);
    }

    ThisType& exchangeCode(Int32NULL value) noexcept
    {
        constexpr BlockLength offset = 0;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& exchangeCode(NullOpt) noexcept
    {
        constexpr BlockLength offset = 0;
 
        setOrdinary(offset, NullInt32NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto text() const noexcept
    {
        constexpr BlockLength offset = 4;
        constexpr BlockLength length = 100;
 
        return fixedStr<length>(offset, optional);
    }

    ThisType& text(StrRef value) noexcept
    {
        constexpr BlockLength offset = 4;
        constexpr BlockLength length = 100;
 
        setFixedStr<length>(offset, value);
        return *this;
    }
 
    ThisType& text(NullOpt) noexcept
    {
        constexpr BlockLength offset = 4;
        constexpr BlockLength length = 100;
 
        setFixedStr<length>(offset, StrRef());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    Users users() const noexcept
    {
        return getGroup<Users>(UsersAccess(), *this);
    }

    ONIXS_ICEBOE_NODISCARD
    Users users() noexcept
    {
        return getGroup<Users>(UsersAccess(), *this);
    }

    Users users(Users::Size length)
    {
        return constructGroup<Users>(
            UsersAccess(),
            length,
            *this);
    }

    Users users(Users::Size length, NoFieldsInit)
    {
        return setupGroup<Users>(
            UsersAccess(),
            length,
            *this);
    }

    constexpr
    static BlockLength minimalBlockLength(ONIXS_ICEBOE_UNUSED SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            104;
    }

    constexpr
    static BlockLength blockLength(SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            minimalBlockLength(version);
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static MessageSize getMinimalVariableFieldsSize(ONIXS_ICEBOE_UNUSED SchemaVersion version)
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            static_cast<MessageSize>(Users::EmptySize);
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static UInt64 getMaxMessageSize(UInt8 maxGroupItems = 255) noexcept
    {
        return
            static_cast<UInt64>(MessageHeaderBuilder::Size) +
            blockLength(Schema::Version) +
            (GroupSizeEncoding::Size + UsersEntry::blockLength(Schema::Version) * static_cast<UInt64>(maxGroupItems));
    }

    ThisType& resetVariableFields() noexcept
    {
        users(nullOpt);
        return *this;
    }

    ThisType& reset() noexcept
    {
        exchangeCode(nullOpt);
        text(nullOpt);
 
        resetVariableFields();
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef className() noexcept
    {
        return constructStrRef("IPReport");
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef fixType() noexcept
    {
        return constructStrRef("IPReport");
    }

    ONIXS_ICEBOE_NODISCARD
    std::string toString() const;

    ONIXS_ICEBOE_NODISCARD
    const void* tail() const noexcept
    {
        return
            users().tail();
    }

    ONIXS_ICEBOE_NODISCARD
    EncodedLength calculateBinarySize() const noexcept
    {
        return
            SbeMessage::calculateBinarySize(tail());
    }
 
private:
    void checkLength(
        EncodedLength length, SchemaVersion version) const
    {
       const EncodedLength minimalRequiredLength =
           minimalBlockLength(version) +
           MessageHeader::Size +
           getMinimalVariableFieldsSize(version);
 
       checkBinaryLength(
           *this, length, minimalRequiredLength);
    }

    void checkVarLenFields() const
    {
        groups().
            checkTail<Users>();
    }
 
    void checkCompatibility() const
    {
        assert(TemplateId == templateId());
 
        checkSchema<Schema>(schemaId(), version());
        checkLength(bufferSize(), version());
        checkVarLenFields();
    }

    struct UsersAccess
    {
        Users operator()(const IPReport& obj) const noexcept
        {
            return obj.
                groups().
                    head<Users>();
        }
    };

    void users(NullOpt) noexcept
    {
        resetGroup<Users>(UsersAccess(), *this);
    }
};

struct
TraderLogonRequest
: SbeMessage
{
    typedef SchemaTraits Schema;

    typedef TraderLogonRequest ThisType;

    enum { TemplateId = 2 };

    TraderLogonRequest() = default;

    TraderLogonRequest(void* data, EncodedLength length, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        reset();
    }

    TraderLogonRequest(void* data, EncodedLength length, NoFieldsInit, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        resetVariableFields();
    }

    TraderLogonRequest(void* data, EncodedLength length, NoInit)
      : SbeMessage(data, length)
    {
        checkCompatibility();
    }

    explicit
    TraderLogonRequest(const SbeMessage& message)
      : SbeMessage(message)
    {
        assert(message.valid());
 
        checkCompatibility();
    }

    TraderLogonRequest(void* data, EncodedLength length, NoInit, NoCheck) noexcept
      : SbeMessage(data, length, NoCheck())
    {
        assert(schemaId() == Schema::Id);
        assert(version() >= Schema::MinimalVersion);
        assert(TemplateId == templateId());
    }

    ONIXS_ICEBOE_NODISCARD
    auto originatorUserId() const noexcept
    {
        constexpr BlockLength offset = 0;
        constexpr BlockLength length = 20;
 
        return fixedStr<length>(offset);
    }

    ThisType& originatorUserId(StrRef value) noexcept
    {
        constexpr BlockLength offset = 0;
        constexpr BlockLength length = 20;
 
        setFixedStr<length>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto directElectronicAccess() const noexcept
    {
        constexpr BlockLength offset = 20;
 
        return enumeration<BooleanEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& directElectronicAccess(BooleanEnum value) noexcept
    {
        constexpr BlockLength offset = 20;
 
        setEnumeration<BooleanEnum>(offset, value);
        return *this;
    }
 
    ThisType& directElectronicAccess(NullOpt) noexcept
    {
        constexpr BlockLength offset = 20;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto tradingCapacity() const noexcept
    {
        constexpr BlockLength offset = 21;
 
        return enumeration<TradingCapacityEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& tradingCapacity(TradingCapacityEnum value) noexcept
    {
        constexpr BlockLength offset = 21;
 
        setEnumeration<TradingCapacityEnum>(offset, value);
        return *this;
    }
 
    ThisType& tradingCapacity(NullOpt) noexcept
    {
        constexpr BlockLength offset = 21;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto liquidityProvision() const noexcept
    {
        constexpr BlockLength offset = 22;
 
        return enumeration<BooleanEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& liquidityProvision(BooleanEnum value) noexcept
    {
        constexpr BlockLength offset = 22;
 
        setEnumeration<BooleanEnum>(offset, value);
        return *this;
    }
 
    ThisType& liquidityProvision(NullOpt) noexcept
    {
        constexpr BlockLength offset = 22;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto commodityDerivIndicator() const noexcept
    {
        constexpr BlockLength offset = 23;
 
        return enumeration<BooleanEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& commodityDerivIndicator(BooleanEnum value) noexcept
    {
        constexpr BlockLength offset = 23;
 
        setEnumeration<BooleanEnum>(offset, value);
        return *this;
    }
 
    ThisType& commodityDerivIndicator(NullOpt) noexcept
    {
        constexpr BlockLength offset = 23;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto investmentDecision() const noexcept
    {
        constexpr BlockLength offset = 24;
 
        return ordinary<NullInt64NULL>(offset, optional);
    }

    ThisType& investmentDecision(Int64NULL value) noexcept
    {
        constexpr BlockLength offset = 24;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& investmentDecision(NullOpt) noexcept
    {
        constexpr BlockLength offset = 24;
 
        setOrdinary(offset, NullInt64NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto executionDecision() const noexcept
    {
        constexpr BlockLength offset = 32;
 
        return ordinary<NullInt64NULL>(offset, optional);
    }

    ThisType& executionDecision(Int64NULL value) noexcept
    {
        constexpr BlockLength offset = 32;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& executionDecision(NullOpt) noexcept
    {
        constexpr BlockLength offset = 32;
 
        setOrdinary(offset, NullInt64NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto clientIdCode() const noexcept
    {
        constexpr BlockLength offset = 40;
 
        return ordinary<NullInt64NULL>(offset, optional);
    }

    ThisType& clientIdCode(Int64NULL value) noexcept
    {
        constexpr BlockLength offset = 40;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& clientIdCode(NullOpt) noexcept
    {
        constexpr BlockLength offset = 40;
 
        setOrdinary(offset, NullInt64NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto mifidId() const noexcept
    {
        constexpr BlockLength offset = 48;
 
        return ordinary<NullInt64NULL>(offset, optional);
    }

    ThisType& mifidId(Int64NULL value) noexcept
    {
        constexpr BlockLength offset = 48;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& mifidId(NullOpt) noexcept
    {
        constexpr BlockLength offset = 48;
 
        setOrdinary(offset, NullInt64NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto rawData() const noexcept
    {
        constexpr BlockLength offset = 56;
        constexpr BlockLength length = 50;
 
        return fixedStr<length>(offset);
    }

    ThisType& rawData(StrRef value) noexcept
    {
        constexpr BlockLength offset = 56;
        constexpr BlockLength length = 50;
 
        setFixedStr<length>(offset, value);
        return *this;
    }

    constexpr
    static BlockLength minimalBlockLength(ONIXS_ICEBOE_UNUSED SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            106;
    }

    constexpr
    static BlockLength blockLength(SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            minimalBlockLength(version);
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static MessageSize getMinimalVariableFieldsSize(ONIXS_ICEBOE_UNUSED SchemaVersion version)
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            0;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static UInt64 getMaxMessageSize(UInt8) noexcept
    {
        return
            static_cast<UInt64>(MessageHeaderBuilder::Size) +
            blockLength(Schema::Version);
    }

    ThisType& resetVariableFields() noexcept
    {
        return *this;
    }

    ThisType& reset() noexcept
    {
        directElectronicAccess(nullOpt);
        tradingCapacity(nullOpt);
        liquidityProvision(nullOpt);
        commodityDerivIndicator(nullOpt);
        investmentDecision(nullOpt);
        executionDecision(nullOpt);
        clientIdCode(nullOpt);
        mifidId(nullOpt);
 
        resetVariableFields();
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef className() noexcept
    {
        return constructStrRef("TraderLogonRequest");
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef fixType() noexcept
    {
        return constructStrRef("TraderLogonRequest");
    }

    ONIXS_ICEBOE_NODISCARD
    std::string toString() const;

    ONIXS_ICEBOE_NODISCARD
    const void* tail() const noexcept
    {
        return
            toOpaquePtr(
                advanceByBytes(
                    binary(),
                    static_cast<ptrdiff_t>(SbeMessage::blockLength()) +
                        MessageHeader::Size));
    }

    ONIXS_ICEBOE_NODISCARD
    EncodedLength calculateBinarySize() const noexcept
    {
        return
            SbeMessage::calculateBinarySize(tail());
    }
 
private:
    void checkLength(
        EncodedLength length, SchemaVersion version) const
    {
       const EncodedLength minimalRequiredLength =
           minimalBlockLength(version) +
           MessageHeader::Size +
           getMinimalVariableFieldsSize(version);
 
       checkBinaryLength(
           *this, length, minimalRequiredLength);
    }
 
    void checkCompatibility() const
    {
        assert(TemplateId == templateId());
 
        checkSchema<Schema>(schemaId(), version());
        checkLength(bufferSize(), version());
    }
};

struct
TraderLogonReport
: SbeMessage
{
    typedef SchemaTraits Schema;

    typedef TraderLogonReport ThisType;

    enum { TemplateId = 102 };

    TraderLogonReport() = default;

    TraderLogonReport(void* data, EncodedLength length, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        reset();
    }

    TraderLogonReport(void* data, EncodedLength length, NoFieldsInit, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        resetVariableFields();
    }

    TraderLogonReport(void* data, EncodedLength length, NoInit)
      : SbeMessage(data, length)
    {
        checkCompatibility();
    }

    explicit
    TraderLogonReport(const SbeMessage& message)
      : SbeMessage(message)
    {
        assert(message.valid());
 
        checkCompatibility();
    }

    TraderLogonReport(void* data, EncodedLength length, NoInit, NoCheck) noexcept
      : SbeMessage(data, length, NoCheck())
    {
        assert(schemaId() == Schema::Id);
        assert(version() >= Schema::MinimalVersion);
        assert(TemplateId == templateId());
    }

    ONIXS_ICEBOE_NODISCARD
    auto originatorUserId() const noexcept
    {
        constexpr BlockLength offset = 0;
        constexpr BlockLength length = 20;
 
        return fixedStr<length>(offset);
    }

    ThisType& originatorUserId(StrRef value) noexcept
    {
        constexpr BlockLength offset = 0;
        constexpr BlockLength length = 20;
 
        setFixedStr<length>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto clientId() const noexcept
    {
        constexpr BlockLength offset = 20;
 
        return ordinary<Int32>(offset);
    }

    ThisType& clientId(Int32 value) noexcept
    {
        constexpr BlockLength offset = 20;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto exchangeCode() const noexcept
    {
        constexpr BlockLength offset = 24;
 
        return ordinary<NullInt32NULL>(offset, optional);
    }

    ThisType& exchangeCode(Int32NULL value) noexcept
    {
        constexpr BlockLength offset = 24;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& exchangeCode(NullOpt) noexcept
    {
        constexpr BlockLength offset = 24;
 
        setOrdinary(offset, NullInt32NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto text() const noexcept
    {
        constexpr BlockLength offset = 28;
        constexpr BlockLength length = 100;
 
        return fixedStr<length>(offset, optional);
    }

    ThisType& text(StrRef value) noexcept
    {
        constexpr BlockLength offset = 28;
        constexpr BlockLength length = 100;
 
        setFixedStr<length>(offset, value);
        return *this;
    }
 
    ThisType& text(NullOpt) noexcept
    {
        constexpr BlockLength offset = 28;
        constexpr BlockLength length = 100;
 
        setFixedStr<length>(offset, StrRef());
        return *this;
    }

    constexpr
    static BlockLength minimalBlockLength(ONIXS_ICEBOE_UNUSED SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            128;
    }

    constexpr
    static BlockLength blockLength(SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            minimalBlockLength(version);
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static MessageSize getMinimalVariableFieldsSize(ONIXS_ICEBOE_UNUSED SchemaVersion version)
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            0;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static UInt64 getMaxMessageSize(UInt8) noexcept
    {
        return
            static_cast<UInt64>(MessageHeaderBuilder::Size) +
            blockLength(Schema::Version);
    }

    ThisType& resetVariableFields() noexcept
    {
        return *this;
    }

    ThisType& reset() noexcept
    {
        exchangeCode(nullOpt);
        text(nullOpt);
 
        resetVariableFields();
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef className() noexcept
    {
        return constructStrRef("TraderLogonReport");
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef fixType() noexcept
    {
        return constructStrRef("TraderLogonReport");
    }

    ONIXS_ICEBOE_NODISCARD
    std::string toString() const;

    ONIXS_ICEBOE_NODISCARD
    const void* tail() const noexcept
    {
        return
            toOpaquePtr(
                advanceByBytes(
                    binary(),
                    static_cast<ptrdiff_t>(SbeMessage::blockLength()) +
                        MessageHeader::Size));
    }

    ONIXS_ICEBOE_NODISCARD
    EncodedLength calculateBinarySize() const noexcept
    {
        return
            SbeMessage::calculateBinarySize(tail());
    }
 
private:
    void checkLength(
        EncodedLength length, SchemaVersion version) const
    {
       const EncodedLength minimalRequiredLength =
           minimalBlockLength(version) +
           MessageHeader::Size +
           getMinimalVariableFieldsSize(version);
 
       checkBinaryLength(
           *this, length, minimalRequiredLength);
    }
 
    void checkCompatibility() const
    {
        assert(TemplateId == templateId());
 
        checkSchema<Schema>(schemaId(), version());
        checkLength(bufferSize(), version());
    }
};

struct
TraderLogoutRequest
: SbeMessage
{
    typedef SchemaTraits Schema;

    typedef TraderLogoutRequest ThisType;

    enum { TemplateId = 3 };

    TraderLogoutRequest() = default;

    TraderLogoutRequest(void* data, EncodedLength length, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        reset();
    }

    TraderLogoutRequest(void* data, EncodedLength length, NoFieldsInit, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        resetVariableFields();
    }

    TraderLogoutRequest(void* data, EncodedLength length, NoInit)
      : SbeMessage(data, length)
    {
        checkCompatibility();
    }

    explicit
    TraderLogoutRequest(const SbeMessage& message)
      : SbeMessage(message)
    {
        assert(message.valid());
 
        checkCompatibility();
    }

    TraderLogoutRequest(void* data, EncodedLength length, NoInit, NoCheck) noexcept
      : SbeMessage(data, length, NoCheck())
    {
        assert(schemaId() == Schema::Id);
        assert(version() >= Schema::MinimalVersion);
        assert(TemplateId == templateId());
    }

    ONIXS_ICEBOE_NODISCARD
    auto originatorUserId() const noexcept
    {
        constexpr BlockLength offset = 0;
        constexpr BlockLength length = 20;
 
        return fixedStr<length>(offset);
    }

    ThisType& originatorUserId(StrRef value) noexcept
    {
        constexpr BlockLength offset = 0;
        constexpr BlockLength length = 20;
 
        setFixedStr<length>(offset, value);
        return *this;
    }

    constexpr
    static BlockLength minimalBlockLength(ONIXS_ICEBOE_UNUSED SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            20;
    }

    constexpr
    static BlockLength blockLength(SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            minimalBlockLength(version);
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static MessageSize getMinimalVariableFieldsSize(ONIXS_ICEBOE_UNUSED SchemaVersion version)
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            0;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static UInt64 getMaxMessageSize(UInt8) noexcept
    {
        return
            static_cast<UInt64>(MessageHeaderBuilder::Size) +
            blockLength(Schema::Version);
    }

    ThisType& resetVariableFields() noexcept
    {
        return *this;
    }

    ThisType& reset() noexcept
    {
        resetVariableFields();
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef className() noexcept
    {
        return constructStrRef("TraderLogoutRequest");
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef fixType() noexcept
    {
        return constructStrRef("TraderLogoutRequest");
    }

    ONIXS_ICEBOE_NODISCARD
    std::string toString() const;

    ONIXS_ICEBOE_NODISCARD
    const void* tail() const noexcept
    {
        return
            toOpaquePtr(
                advanceByBytes(
                    binary(),
                    static_cast<ptrdiff_t>(SbeMessage::blockLength()) +
                        MessageHeader::Size));
    }

    ONIXS_ICEBOE_NODISCARD
    EncodedLength calculateBinarySize() const noexcept
    {
        return
            SbeMessage::calculateBinarySize(tail());
    }
 
private:
    void checkLength(
        EncodedLength length, SchemaVersion version) const
    {
       const EncodedLength minimalRequiredLength =
           minimalBlockLength(version) +
           MessageHeader::Size +
           getMinimalVariableFieldsSize(version);
 
       checkBinaryLength(
           *this, length, minimalRequiredLength);
    }
 
    void checkCompatibility() const
    {
        assert(TemplateId == templateId());
 
        checkSchema<Schema>(schemaId(), version());
        checkLength(bufferSize(), version());
    }
};

struct
TraderLogoutReport
: SbeMessage
{
    typedef SchemaTraits Schema;

    typedef TraderLogoutReport ThisType;

    enum { TemplateId = 103 };

    TraderLogoutReport() = default;

    TraderLogoutReport(void* data, EncodedLength length, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        reset();
    }

    TraderLogoutReport(void* data, EncodedLength length, NoFieldsInit, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        resetVariableFields();
    }

    TraderLogoutReport(void* data, EncodedLength length, NoInit)
      : SbeMessage(data, length)
    {
        checkCompatibility();
    }

    explicit
    TraderLogoutReport(const SbeMessage& message)
      : SbeMessage(message)
    {
        assert(message.valid());
 
        checkCompatibility();
    }

    TraderLogoutReport(void* data, EncodedLength length, NoInit, NoCheck) noexcept
      : SbeMessage(data, length, NoCheck())
    {
        assert(schemaId() == Schema::Id);
        assert(version() >= Schema::MinimalVersion);
        assert(TemplateId == templateId());
    }

    ONIXS_ICEBOE_NODISCARD
    auto originatorUserId() const noexcept
    {
        constexpr BlockLength offset = 0;
        constexpr BlockLength length = 20;
 
        return fixedStr<length>(offset);
    }

    ThisType& originatorUserId(StrRef value) noexcept
    {
        constexpr BlockLength offset = 0;
        constexpr BlockLength length = 20;
 
        setFixedStr<length>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto exchangeCode() const noexcept
    {
        constexpr BlockLength offset = 20;
 
        return ordinary<NullInt32NULL>(offset, optional);
    }

    ThisType& exchangeCode(Int32NULL value) noexcept
    {
        constexpr BlockLength offset = 20;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& exchangeCode(NullOpt) noexcept
    {
        constexpr BlockLength offset = 20;
 
        setOrdinary(offset, NullInt32NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto text() const noexcept
    {
        constexpr BlockLength offset = 24;
        constexpr BlockLength length = 100;
 
        return fixedStr<length>(offset, optional);
    }

    ThisType& text(StrRef value) noexcept
    {
        constexpr BlockLength offset = 24;
        constexpr BlockLength length = 100;
 
        setFixedStr<length>(offset, value);
        return *this;
    }
 
    ThisType& text(NullOpt) noexcept
    {
        constexpr BlockLength offset = 24;
        constexpr BlockLength length = 100;
 
        setFixedStr<length>(offset, StrRef());
        return *this;
    }

    constexpr
    static BlockLength minimalBlockLength(ONIXS_ICEBOE_UNUSED SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            124;
    }

    constexpr
    static BlockLength blockLength(SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            minimalBlockLength(version);
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static MessageSize getMinimalVariableFieldsSize(ONIXS_ICEBOE_UNUSED SchemaVersion version)
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            0;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static UInt64 getMaxMessageSize(UInt8) noexcept
    {
        return
            static_cast<UInt64>(MessageHeaderBuilder::Size) +
            blockLength(Schema::Version);
    }

    ThisType& resetVariableFields() noexcept
    {
        return *this;
    }

    ThisType& reset() noexcept
    {
        exchangeCode(nullOpt);
        text(nullOpt);
 
        resetVariableFields();
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef className() noexcept
    {
        return constructStrRef("TraderLogoutReport");
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef fixType() noexcept
    {
        return constructStrRef("TraderLogoutReport");
    }

    ONIXS_ICEBOE_NODISCARD
    std::string toString() const;

    ONIXS_ICEBOE_NODISCARD
    const void* tail() const noexcept
    {
        return
            toOpaquePtr(
                advanceByBytes(
                    binary(),
                    static_cast<ptrdiff_t>(SbeMessage::blockLength()) +
                        MessageHeader::Size));
    }

    ONIXS_ICEBOE_NODISCARD
    EncodedLength calculateBinarySize() const noexcept
    {
        return
            SbeMessage::calculateBinarySize(tail());
    }
 
private:
    void checkLength(
        EncodedLength length, SchemaVersion version) const
    {
       const EncodedLength minimalRequiredLength =
           minimalBlockLength(version) +
           MessageHeader::Size +
           getMinimalVariableFieldsSize(version);
 
       checkBinaryLength(
           *this, length, minimalRequiredLength);
    }
 
    void checkCompatibility() const
    {
        assert(TemplateId == templateId());
 
        checkSchema<Schema>(schemaId(), version());
        checkLength(bufferSize(), version());
    }
};

struct
NewOrderRequest
: SbeMessage
{
    typedef SchemaTraits Schema;

    typedef NewOrderRequest ThisType;

    enum { TemplateId = 4 };

    NewOrderRequest() = default;

    NewOrderRequest(void* data, EncodedLength length, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        reset();
    }

    NewOrderRequest(void* data, EncodedLength length, NoFieldsInit, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        resetVariableFields();
    }

    NewOrderRequest(void* data, EncodedLength length, NoInit)
      : SbeMessage(data, length)
    {
        checkCompatibility();
    }

    explicit
    NewOrderRequest(const SbeMessage& message)
      : SbeMessage(message)
    {
        assert(message.valid());
 
        checkCompatibility();
    }

    NewOrderRequest(void* data, EncodedLength length, NoInit, NoCheck) noexcept
      : SbeMessage(data, length, NoCheck())
    {
        assert(schemaId() == Schema::Id);
        assert(version() >= Schema::MinimalVersion);
        assert(TemplateId == templateId());
    }

    ONIXS_ICEBOE_NODISCARD
    auto price() const noexcept
    {
        constexpr BlockLength offset = 0;
 
        return ordinary<NullDecimal9>(offset, optional);
    }

    ThisType& price(Decimal9 value) noexcept
    {
        constexpr BlockLength offset = 0;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& price(NullOpt) noexcept
    {
        constexpr BlockLength offset = 0;
 
        setOrdinary(offset, NullDecimal9());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto orderQty() const noexcept
    {
        constexpr BlockLength offset = 8;
 
        return ordinary<Decimal9>(offset);
    }

    ThisType& orderQty(Decimal9 value) noexcept
    {
        constexpr BlockLength offset = 8;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto symbol() const noexcept
    {
        constexpr BlockLength offset = 16;
 
        return ordinary<Int32>(offset);
    }

    ThisType& symbol(Int32 value) noexcept
    {
        constexpr BlockLength offset = 16;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto timeInForce() const noexcept
    {
        constexpr BlockLength offset = 20;
 
        return enumeration<TimeInForceEnum>(offset);
    }

    ThisType& timeInForce(TimeInForceEnum value) noexcept
    {
        constexpr BlockLength offset = 20;
 
        setEnumeration<TimeInForceEnum>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto side() const noexcept
    {
        constexpr BlockLength offset = 21;
 
        return enumeration<SideEnum>(offset);
    }

    ThisType& side(SideEnum value) noexcept
    {
        constexpr BlockLength offset = 21;
 
        setEnumeration<SideEnum>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto originatorUserId() const noexcept
    {
        constexpr BlockLength offset = 22;
        constexpr BlockLength length = 20;
 
        return fixedStr<length>(offset);
    }

    ThisType& originatorUserId(StrRef value) noexcept
    {
        constexpr BlockLength offset = 22;
        constexpr BlockLength length = 20;
 
        setFixedStr<length>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto ordType() const noexcept
    {
        constexpr BlockLength offset = 42;
 
        return enumeration<OrderTypeEnum>(offset);
    }

    ThisType& ordType(OrderTypeEnum value) noexcept
    {
        constexpr BlockLength offset = 42;
 
        setEnumeration<OrderTypeEnum>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto manualOrderIndicator() const noexcept
    {
        constexpr BlockLength offset = 43;
 
        return enumeration<BooleanEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& manualOrderIndicator(BooleanEnum value) noexcept
    {
        constexpr BlockLength offset = 43;
 
        setEnumeration<BooleanEnum>(offset, value);
        return *this;
    }
 
    ThisType& manualOrderIndicator(NullOpt) noexcept
    {
        constexpr BlockLength offset = 43;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto clOrdId() const noexcept
    {
        constexpr BlockLength offset = 44;
 
        return ordinary<Int64>(offset);
    }

    ThisType& clOrdId(Int64 value) noexcept
    {
        constexpr BlockLength offset = 44;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto maxShow() const noexcept
    {
        constexpr BlockLength offset = 52;
 
        return ordinary<NullDecimal9>(offset, optional);
    }

    ThisType& maxShow(Decimal9 value) noexcept
    {
        constexpr BlockLength offset = 52;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& maxShow(NullOpt) noexcept
    {
        constexpr BlockLength offset = 52;
 
        setOrdinary(offset, NullDecimal9());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto stopPx() const noexcept
    {
        constexpr BlockLength offset = 60;
 
        return ordinary<NullDecimal9>(offset, optional);
    }

    ThisType& stopPx(Decimal9 value) noexcept
    {
        constexpr BlockLength offset = 60;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& stopPx(NullOpt) noexcept
    {
        constexpr BlockLength offset = 60;
 
        setOrdinary(offset, NullDecimal9());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto giveUpClearingFirm() const noexcept
    {
        constexpr BlockLength offset = 68;
 
        return ordinary<NullInt32NULL>(offset, optional);
    }

    ThisType& giveUpClearingFirm(Int32NULL value) noexcept
    {
        constexpr BlockLength offset = 68;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& giveUpClearingFirm(NullOpt) noexcept
    {
        constexpr BlockLength offset = 68;
 
        setOrdinary(offset, NullInt32NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto clearingFirm() const noexcept
    {
        constexpr BlockLength offset = 72;
 
        return ordinary<Int32>(offset);
    }

    ThisType& clearingFirm(Int32 value) noexcept
    {
        constexpr BlockLength offset = 72;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto selfMatchPreventionId() const noexcept
    {
        constexpr BlockLength offset = 76;
 
        return ordinary<NullInt64NULL>(offset, optional);
    }

    ThisType& selfMatchPreventionId(Int64NULL value) noexcept
    {
        constexpr BlockLength offset = 76;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& selfMatchPreventionId(NullOpt) noexcept
    {
        constexpr BlockLength offset = 76;
 
        setOrdinary(offset, NullInt64NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto expireDate() const noexcept(dateToTimestamp::Nothrow)
    {
        constexpr BlockLength offset = 84;
        return convertible<NullUTCDateOnly, dateToTimestamp>(offset, optional);
    }

    ThisType& expireDate(Timestamp value) noexcept(timestampToDate::Nothrow)
    {
        constexpr BlockLength offset = 84;
 
        setOrdinary(offset, convert<timestampToDate>(value));
        return *this;
    }
 
    ThisType& expireDate(NullOpt) noexcept
    {
        constexpr BlockLength offset = 84;
 
        setOrdinary(offset, NullUTCDateOnly());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto selfMatchPreventionInstruction() const noexcept
    {
        constexpr BlockLength offset = 86;
 
        return enumeration<SelfMatchPreventionInstructionEnum, NullCharType>(offset, optional);
    }

    ThisType& selfMatchPreventionInstruction(SelfMatchPreventionInstructionEnum value) noexcept
    {
        constexpr BlockLength offset = 86;
 
        setEnumeration<SelfMatchPreventionInstructionEnum>(offset, value);
        return *this;
    }
 
    ThisType& selfMatchPreventionInstruction(NullOpt) noexcept
    {
        constexpr BlockLength offset = 86;
 
        setOrdinary(offset, NullCharType());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto execInst() const noexcept
    {
        constexpr BlockLength offset = 87;
 
        return enumeration<ExecInstEnum, NullCharType>(offset, optional);
    }

    ThisType& execInst(ExecInstEnum value) noexcept
    {
        constexpr BlockLength offset = 87;
 
        setEnumeration<ExecInstEnum>(offset, value);
        return *this;
    }
 
    ThisType& execInst(NullOpt) noexcept
    {
        constexpr BlockLength offset = 87;
 
        setOrdinary(offset, NullCharType());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto directElectronicAccess() const noexcept
    {
        constexpr BlockLength offset = 88;
 
        return enumeration<BooleanEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& directElectronicAccess(BooleanEnum value) noexcept
    {
        constexpr BlockLength offset = 88;
 
        setEnumeration<BooleanEnum>(offset, value);
        return *this;
    }
 
    ThisType& directElectronicAccess(NullOpt) noexcept
    {
        constexpr BlockLength offset = 88;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto tradingCapacity() const noexcept
    {
        constexpr BlockLength offset = 89;
 
        return enumeration<TradingCapacityEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& tradingCapacity(TradingCapacityEnum value) noexcept
    {
        constexpr BlockLength offset = 89;
 
        setEnumeration<TradingCapacityEnum>(offset, value);
        return *this;
    }
 
    ThisType& tradingCapacity(NullOpt) noexcept
    {
        constexpr BlockLength offset = 89;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto liquidityProvision() const noexcept
    {
        constexpr BlockLength offset = 90;
 
        return enumeration<BooleanEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& liquidityProvision(BooleanEnum value) noexcept
    {
        constexpr BlockLength offset = 90;
 
        setEnumeration<BooleanEnum>(offset, value);
        return *this;
    }
 
    ThisType& liquidityProvision(NullOpt) noexcept
    {
        constexpr BlockLength offset = 90;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto commodityDerivIndicator() const noexcept
    {
        constexpr BlockLength offset = 91;
 
        return enumeration<BooleanEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& commodityDerivIndicator(BooleanEnum value) noexcept
    {
        constexpr BlockLength offset = 91;
 
        setEnumeration<BooleanEnum>(offset, value);
        return *this;
    }
 
    ThisType& commodityDerivIndicator(NullOpt) noexcept
    {
        constexpr BlockLength offset = 91;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto investmentDecision() const noexcept
    {
        constexpr BlockLength offset = 92;
 
        return ordinary<NullInt64NULL>(offset, optional);
    }

    ThisType& investmentDecision(Int64NULL value) noexcept
    {
        constexpr BlockLength offset = 92;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& investmentDecision(NullOpt) noexcept
    {
        constexpr BlockLength offset = 92;
 
        setOrdinary(offset, NullInt64NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto executionDecision() const noexcept
    {
        constexpr BlockLength offset = 100;
 
        return ordinary<NullInt64NULL>(offset, optional);
    }

    ThisType& executionDecision(Int64NULL value) noexcept
    {
        constexpr BlockLength offset = 100;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& executionDecision(NullOpt) noexcept
    {
        constexpr BlockLength offset = 100;
 
        setOrdinary(offset, NullInt64NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto clientIdCode() const noexcept
    {
        constexpr BlockLength offset = 108;
 
        return ordinary<NullInt64NULL>(offset, optional);
    }

    ThisType& clientIdCode(Int64NULL value) noexcept
    {
        constexpr BlockLength offset = 108;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& clientIdCode(NullOpt) noexcept
    {
        constexpr BlockLength offset = 108;
 
        setOrdinary(offset, NullInt64NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto mifidId() const noexcept
    {
        constexpr BlockLength offset = 116;
 
        return ordinary<NullInt64NULL>(offset, optional);
    }

    ThisType& mifidId(Int64NULL value) noexcept
    {
        constexpr BlockLength offset = 116;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& mifidId(NullOpt) noexcept
    {
        constexpr BlockLength offset = 116;
 
        setOrdinary(offset, NullInt64NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto custOrderHandlingInst() const noexcept
    {
        constexpr BlockLength offset = 124;
 
        return enumeration<CustOrderHandlingInstEnum, NullCharType>(offset, optional);
    }

    ThisType& custOrderHandlingInst(CustOrderHandlingInstEnum value) noexcept
    {
        constexpr BlockLength offset = 124;
 
        setEnumeration<CustOrderHandlingInstEnum>(offset, value);
        return *this;
    }
 
    ThisType& custOrderHandlingInst(NullOpt) noexcept
    {
        constexpr BlockLength offset = 124;
 
        setOrdinary(offset, NullCharType());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto positionEffect() const noexcept
    {
        constexpr BlockLength offset = 125;
 
        return enumeration<PositionEffectEnum, NullCharType>(offset, optional);
    }

    ThisType& positionEffect(PositionEffectEnum value) noexcept
    {
        constexpr BlockLength offset = 125;
 
        setEnumeration<PositionEffectEnum>(offset, value);
        return *this;
    }
 
    ThisType& positionEffect(NullOpt) noexcept
    {
        constexpr BlockLength offset = 125;
 
        setOrdinary(offset, NullCharType());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto allocHandlInst() const noexcept
    {
        constexpr BlockLength offset = 126;
 
        return enumeration<AllocHandlInstEnum, NullCharType>(offset, optional);
    }

    ThisType& allocHandlInst(AllocHandlInstEnum value) noexcept
    {
        constexpr BlockLength offset = 126;
 
        setEnumeration<AllocHandlInstEnum>(offset, value);
        return *this;
    }
 
    ThisType& allocHandlInst(NullOpt) noexcept
    {
        constexpr BlockLength offset = 126;
 
        setOrdinary(offset, NullCharType());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto priceType() const noexcept
    {
        constexpr BlockLength offset = 127;
 
        return enumeration<PriceTypeEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& priceType(PriceTypeEnum value) noexcept
    {
        constexpr BlockLength offset = 127;
 
        setEnumeration<PriceTypeEnum>(offset, value);
        return *this;
    }
 
    ThisType& priceType(NullOpt) noexcept
    {
        constexpr BlockLength offset = 127;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto clearingAccount() const noexcept
    {
        constexpr BlockLength offset = 128;
        constexpr BlockLength length = 14;
 
        return fixedStr<length>(offset);
    }

    ThisType& clearingAccount(StrRef value) noexcept
    {
        constexpr BlockLength offset = 128;
        constexpr BlockLength length = 14;
 
        setFixedStr<length>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto customerAccountRefId() const noexcept
    {
        constexpr BlockLength offset = 142;
        constexpr BlockLength length = 12;
 
        return fixedStr<length>(offset, optional);
    }

    ThisType& customerAccountRefId(StrRef value) noexcept
    {
        constexpr BlockLength offset = 142;
        constexpr BlockLength length = 12;
 
        setFixedStr<length>(offset, value);
        return *this;
    }
 
    ThisType& customerAccountRefId(NullOpt) noexcept
    {
        constexpr BlockLength offset = 142;
        constexpr BlockLength length = 12;
 
        setFixedStr<length>(offset, StrRef());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto memo() const noexcept
    {
        constexpr BlockLength offset = 154;
        constexpr BlockLength length = 30;
 
        return fixedStr<length>(offset, optional);
    }

    ThisType& memo(StrRef value) noexcept
    {
        constexpr BlockLength offset = 154;
        constexpr BlockLength length = 30;
 
        setFixedStr<length>(offset, value);
        return *this;
    }
 
    ThisType& memo(NullOpt) noexcept
    {
        constexpr BlockLength offset = 154;
        constexpr BlockLength length = 30;
 
        setFixedStr<length>(offset, StrRef());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto allocationAccount() const noexcept
    {
        constexpr BlockLength offset = 184;
        constexpr BlockLength length = 20;
 
        return fixedStr<length>(offset, optional);
    }

    ThisType& allocationAccount(StrRef value) noexcept
    {
        constexpr BlockLength offset = 184;
        constexpr BlockLength length = 20;
 
        setFixedStr<length>(offset, value);
        return *this;
    }
 
    ThisType& allocationAccount(NullOpt) noexcept
    {
        constexpr BlockLength offset = 184;
        constexpr BlockLength length = 20;
 
        setFixedStr<length>(offset, StrRef());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto onBehalfOfCompId() const noexcept
    {
        constexpr BlockLength offset = 204;
        constexpr BlockLength length = 41;
 
        return fixedStr<length>(offset, optional);
    }

    ThisType& onBehalfOfCompId(StrRef value) noexcept
    {
        constexpr BlockLength offset = 204;
        constexpr BlockLength length = 41;
 
        setFixedStr<length>(offset, value);
        return *this;
    }
 
    ThisType& onBehalfOfCompId(NullOpt) noexcept
    {
        constexpr BlockLength offset = 204;
        constexpr BlockLength length = 41;
 
        setFixedStr<length>(offset, StrRef());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto onBehalfOfSubId() const noexcept
    {
        constexpr BlockLength offset = 245;
        constexpr BlockLength length = 41;
 
        return fixedStr<length>(offset);
    }

    ThisType& onBehalfOfSubId(StrRef value) noexcept
    {
        constexpr BlockLength offset = 245;
        constexpr BlockLength length = 41;
 
        setFixedStr<length>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto onBehalfOfLocationId() const noexcept
    {
        constexpr BlockLength offset = 286;
        constexpr BlockLength length = 41;
 
        return fixedStr<length>(offset);
    }

    ThisType& onBehalfOfLocationId(StrRef value) noexcept
    {
        constexpr BlockLength offset = 286;
        constexpr BlockLength length = 41;
 
        setFixedStr<length>(offset, value);
        return *this;
    }

    constexpr
    static BlockLength minimalBlockLength(ONIXS_ICEBOE_UNUSED SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            327;
    }

    constexpr
    static BlockLength blockLength(SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            minimalBlockLength(version);
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static MessageSize getMinimalVariableFieldsSize(ONIXS_ICEBOE_UNUSED SchemaVersion version)
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            0;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static UInt64 getMaxMessageSize(UInt8) noexcept
    {
        return
            static_cast<UInt64>(MessageHeaderBuilder::Size) +
            blockLength(Schema::Version);
    }

    ThisType& resetVariableFields() noexcept
    {
        return *this;
    }

    ThisType& reset() noexcept
    {
        price(nullOpt);
        manualOrderIndicator(nullOpt);
        maxShow(nullOpt);
        stopPx(nullOpt);
        giveUpClearingFirm(nullOpt);
        selfMatchPreventionId(nullOpt);
        expireDate(nullOpt);
        selfMatchPreventionInstruction(nullOpt);
        execInst(nullOpt);
        directElectronicAccess(nullOpt);
        tradingCapacity(nullOpt);
        liquidityProvision(nullOpt);
        commodityDerivIndicator(nullOpt);
        investmentDecision(nullOpt);
        executionDecision(nullOpt);
        clientIdCode(nullOpt);
        mifidId(nullOpt);
        custOrderHandlingInst(nullOpt);
        positionEffect(nullOpt);
        allocHandlInst(nullOpt);
        priceType(nullOpt);
        customerAccountRefId(nullOpt);
        memo(nullOpt);
        allocationAccount(nullOpt);
        onBehalfOfCompId(nullOpt);
 
        resetVariableFields();
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef className() noexcept
    {
        return constructStrRef("NewOrderRequest");
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef fixType() noexcept
    {
        return constructStrRef("D");
    }

    ONIXS_ICEBOE_NODISCARD
    std::string toString() const;

    ONIXS_ICEBOE_NODISCARD
    const void* tail() const noexcept
    {
        return
            toOpaquePtr(
                advanceByBytes(
                    binary(),
                    static_cast<ptrdiff_t>(SbeMessage::blockLength()) +
                        MessageHeader::Size));
    }

    ONIXS_ICEBOE_NODISCARD
    EncodedLength calculateBinarySize() const noexcept
    {
        return
            SbeMessage::calculateBinarySize(tail());
    }
 
private:
    void checkLength(
        EncodedLength length, SchemaVersion version) const
    {
       const EncodedLength minimalRequiredLength =
           minimalBlockLength(version) +
           MessageHeader::Size +
           getMinimalVariableFieldsSize(version);
 
       checkBinaryLength(
           *this, length, minimalRequiredLength);
    }
 
    void checkCompatibility() const
    {
        assert(TemplateId == templateId());
 
        checkSchema<Schema>(schemaId(), version());
        checkLength(bufferSize(), version());
    }
};

struct
CancelReplaceRequest
: SbeMessage
{
    typedef SchemaTraits Schema;

    typedef CancelReplaceRequest ThisType;

    enum { TemplateId = 5 };

    CancelReplaceRequest() = default;

    CancelReplaceRequest(void* data, EncodedLength length, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        reset();
    }

    CancelReplaceRequest(void* data, EncodedLength length, NoFieldsInit, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        resetVariableFields();
    }

    CancelReplaceRequest(void* data, EncodedLength length, NoInit)
      : SbeMessage(data, length)
    {
        checkCompatibility();
    }

    explicit
    CancelReplaceRequest(const SbeMessage& message)
      : SbeMessage(message)
    {
        assert(message.valid());
 
        checkCompatibility();
    }

    CancelReplaceRequest(void* data, EncodedLength length, NoInit, NoCheck) noexcept
      : SbeMessage(data, length, NoCheck())
    {
        assert(schemaId() == Schema::Id);
        assert(version() >= Schema::MinimalVersion);
        assert(TemplateId == templateId());
    }

    ONIXS_ICEBOE_NODISCARD
    auto price() const noexcept
    {
        constexpr BlockLength offset = 0;
 
        return ordinary<NullDecimal9>(offset, optional);
    }

    ThisType& price(Decimal9 value) noexcept
    {
        constexpr BlockLength offset = 0;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& price(NullOpt) noexcept
    {
        constexpr BlockLength offset = 0;
 
        setOrdinary(offset, NullDecimal9());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto orderQty() const noexcept
    {
        constexpr BlockLength offset = 8;
 
        return ordinary<Decimal9>(offset);
    }

    ThisType& orderQty(Decimal9 value) noexcept
    {
        constexpr BlockLength offset = 8;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto symbol() const noexcept
    {
        constexpr BlockLength offset = 16;
 
        return ordinary<Int32>(offset);
    }

    ThisType& symbol(Int32 value) noexcept
    {
        constexpr BlockLength offset = 16;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto timeInForce() const noexcept
    {
        constexpr BlockLength offset = 20;
 
        return enumeration<TimeInForceEnum>(offset);
    }

    ThisType& timeInForce(TimeInForceEnum value) noexcept
    {
        constexpr BlockLength offset = 20;
 
        setEnumeration<TimeInForceEnum>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto side() const noexcept
    {
        constexpr BlockLength offset = 21;
 
        return enumeration<SideEnum>(offset);
    }

    ThisType& side(SideEnum value) noexcept
    {
        constexpr BlockLength offset = 21;
 
        setEnumeration<SideEnum>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto originatorUserId() const noexcept
    {
        constexpr BlockLength offset = 22;
        constexpr BlockLength length = 20;
 
        return fixedStr<length>(offset);
    }

    ThisType& originatorUserId(StrRef value) noexcept
    {
        constexpr BlockLength offset = 22;
        constexpr BlockLength length = 20;
 
        setFixedStr<length>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto ordType() const noexcept
    {
        constexpr BlockLength offset = 42;
 
        return enumeration<OrderTypeEnum>(offset);
    }

    ThisType& ordType(OrderTypeEnum value) noexcept
    {
        constexpr BlockLength offset = 42;
 
        setEnumeration<OrderTypeEnum>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto manualOrderIndicator() const noexcept
    {
        constexpr BlockLength offset = 43;
 
        return enumeration<BooleanEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& manualOrderIndicator(BooleanEnum value) noexcept
    {
        constexpr BlockLength offset = 43;
 
        setEnumeration<BooleanEnum>(offset, value);
        return *this;
    }
 
    ThisType& manualOrderIndicator(NullOpt) noexcept
    {
        constexpr BlockLength offset = 43;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto clOrdId() const noexcept
    {
        constexpr BlockLength offset = 44;
 
        return ordinary<Int64>(offset);
    }

    ThisType& clOrdId(Int64 value) noexcept
    {
        constexpr BlockLength offset = 44;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto origClOrdId() const noexcept
    {
        constexpr BlockLength offset = 52;
 
        return ordinary<Int64>(offset);
    }

    ThisType& origClOrdId(Int64 value) noexcept
    {
        constexpr BlockLength offset = 52;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto maxShow() const noexcept
    {
        constexpr BlockLength offset = 60;
 
        return ordinary<NullDecimal9>(offset, optional);
    }

    ThisType& maxShow(Decimal9 value) noexcept
    {
        constexpr BlockLength offset = 60;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& maxShow(NullOpt) noexcept
    {
        constexpr BlockLength offset = 60;
 
        setOrdinary(offset, NullDecimal9());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto stopPx() const noexcept
    {
        constexpr BlockLength offset = 68;
 
        return ordinary<NullDecimal9>(offset, optional);
    }

    ThisType& stopPx(Decimal9 value) noexcept
    {
        constexpr BlockLength offset = 68;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& stopPx(NullOpt) noexcept
    {
        constexpr BlockLength offset = 68;
 
        setOrdinary(offset, NullDecimal9());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto giveUpClearingFirm() const noexcept
    {
        constexpr BlockLength offset = 76;
 
        return ordinary<NullInt32NULL>(offset, optional);
    }

    ThisType& giveUpClearingFirm(Int32NULL value) noexcept
    {
        constexpr BlockLength offset = 76;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& giveUpClearingFirm(NullOpt) noexcept
    {
        constexpr BlockLength offset = 76;
 
        setOrdinary(offset, NullInt32NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto clearingFirm() const noexcept
    {
        constexpr BlockLength offset = 80;
 
        return ordinary<Int32>(offset);
    }

    ThisType& clearingFirm(Int32 value) noexcept
    {
        constexpr BlockLength offset = 80;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto selfMatchPreventionId() const noexcept
    {
        constexpr BlockLength offset = 84;
 
        return ordinary<NullInt64NULL>(offset, optional);
    }

    ThisType& selfMatchPreventionId(Int64NULL value) noexcept
    {
        constexpr BlockLength offset = 84;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& selfMatchPreventionId(NullOpt) noexcept
    {
        constexpr BlockLength offset = 84;
 
        setOrdinary(offset, NullInt64NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto expireDate() const noexcept(dateToTimestamp::Nothrow)
    {
        constexpr BlockLength offset = 92;
        return convertible<NullUTCDateOnly, dateToTimestamp>(offset, optional);
    }

    ThisType& expireDate(Timestamp value) noexcept(timestampToDate::Nothrow)
    {
        constexpr BlockLength offset = 92;
 
        setOrdinary(offset, convert<timestampToDate>(value));
        return *this;
    }
 
    ThisType& expireDate(NullOpt) noexcept
    {
        constexpr BlockLength offset = 92;
 
        setOrdinary(offset, NullUTCDateOnly());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto selfMatchPreventionInstruction() const noexcept
    {
        constexpr BlockLength offset = 94;
 
        return enumeration<SelfMatchPreventionInstructionEnum, NullCharType>(offset, optional);
    }

    ThisType& selfMatchPreventionInstruction(SelfMatchPreventionInstructionEnum value) noexcept
    {
        constexpr BlockLength offset = 94;
 
        setEnumeration<SelfMatchPreventionInstructionEnum>(offset, value);
        return *this;
    }
 
    ThisType& selfMatchPreventionInstruction(NullOpt) noexcept
    {
        constexpr BlockLength offset = 94;
 
        setOrdinary(offset, NullCharType());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto execInst() const noexcept
    {
        constexpr BlockLength offset = 95;
 
        return enumeration<ExecInstEnum, NullCharType>(offset, optional);
    }

    ThisType& execInst(ExecInstEnum value) noexcept
    {
        constexpr BlockLength offset = 95;
 
        setEnumeration<ExecInstEnum>(offset, value);
        return *this;
    }
 
    ThisType& execInst(NullOpt) noexcept
    {
        constexpr BlockLength offset = 95;
 
        setOrdinary(offset, NullCharType());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto directElectronicAccess() const noexcept
    {
        constexpr BlockLength offset = 96;
 
        return enumeration<BooleanEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& directElectronicAccess(BooleanEnum value) noexcept
    {
        constexpr BlockLength offset = 96;
 
        setEnumeration<BooleanEnum>(offset, value);
        return *this;
    }
 
    ThisType& directElectronicAccess(NullOpt) noexcept
    {
        constexpr BlockLength offset = 96;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto tradingCapacity() const noexcept
    {
        constexpr BlockLength offset = 97;
 
        return enumeration<TradingCapacityEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& tradingCapacity(TradingCapacityEnum value) noexcept
    {
        constexpr BlockLength offset = 97;
 
        setEnumeration<TradingCapacityEnum>(offset, value);
        return *this;
    }
 
    ThisType& tradingCapacity(NullOpt) noexcept
    {
        constexpr BlockLength offset = 97;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto liquidityProvision() const noexcept
    {
        constexpr BlockLength offset = 98;
 
        return enumeration<BooleanEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& liquidityProvision(BooleanEnum value) noexcept
    {
        constexpr BlockLength offset = 98;
 
        setEnumeration<BooleanEnum>(offset, value);
        return *this;
    }
 
    ThisType& liquidityProvision(NullOpt) noexcept
    {
        constexpr BlockLength offset = 98;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto commodityDerivIndicator() const noexcept
    {
        constexpr BlockLength offset = 99;
 
        return enumeration<BooleanEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& commodityDerivIndicator(BooleanEnum value) noexcept
    {
        constexpr BlockLength offset = 99;
 
        setEnumeration<BooleanEnum>(offset, value);
        return *this;
    }
 
    ThisType& commodityDerivIndicator(NullOpt) noexcept
    {
        constexpr BlockLength offset = 99;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto investmentDecision() const noexcept
    {
        constexpr BlockLength offset = 100;
 
        return ordinary<NullInt64NULL>(offset, optional);
    }

    ThisType& investmentDecision(Int64NULL value) noexcept
    {
        constexpr BlockLength offset = 100;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& investmentDecision(NullOpt) noexcept
    {
        constexpr BlockLength offset = 100;
 
        setOrdinary(offset, NullInt64NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto executionDecision() const noexcept
    {
        constexpr BlockLength offset = 108;
 
        return ordinary<NullInt64NULL>(offset, optional);
    }

    ThisType& executionDecision(Int64NULL value) noexcept
    {
        constexpr BlockLength offset = 108;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& executionDecision(NullOpt) noexcept
    {
        constexpr BlockLength offset = 108;
 
        setOrdinary(offset, NullInt64NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto clientIdCode() const noexcept
    {
        constexpr BlockLength offset = 116;
 
        return ordinary<NullInt64NULL>(offset, optional);
    }

    ThisType& clientIdCode(Int64NULL value) noexcept
    {
        constexpr BlockLength offset = 116;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& clientIdCode(NullOpt) noexcept
    {
        constexpr BlockLength offset = 116;
 
        setOrdinary(offset, NullInt64NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto mifidId() const noexcept
    {
        constexpr BlockLength offset = 124;
 
        return ordinary<NullInt64NULL>(offset, optional);
    }

    ThisType& mifidId(Int64NULL value) noexcept
    {
        constexpr BlockLength offset = 124;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& mifidId(NullOpt) noexcept
    {
        constexpr BlockLength offset = 124;
 
        setOrdinary(offset, NullInt64NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto allocHandlInst() const noexcept
    {
        constexpr BlockLength offset = 132;
 
        return enumeration<AllocHandlInstEnum, NullCharType>(offset, optional);
    }

    ThisType& allocHandlInst(AllocHandlInstEnum value) noexcept
    {
        constexpr BlockLength offset = 132;
 
        setEnumeration<AllocHandlInstEnum>(offset, value);
        return *this;
    }
 
    ThisType& allocHandlInst(NullOpt) noexcept
    {
        constexpr BlockLength offset = 132;
 
        setOrdinary(offset, NullCharType());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto priceType() const noexcept
    {
        constexpr BlockLength offset = 133;
 
        return enumeration<PriceTypeEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& priceType(PriceTypeEnum value) noexcept
    {
        constexpr BlockLength offset = 133;
 
        setEnumeration<PriceTypeEnum>(offset, value);
        return *this;
    }
 
    ThisType& priceType(NullOpt) noexcept
    {
        constexpr BlockLength offset = 133;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto clearingAccount() const noexcept
    {
        constexpr BlockLength offset = 134;
        constexpr BlockLength length = 14;
 
        return fixedStr<length>(offset);
    }

    ThisType& clearingAccount(StrRef value) noexcept
    {
        constexpr BlockLength offset = 134;
        constexpr BlockLength length = 14;
 
        setFixedStr<length>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto customerAccountRefId() const noexcept
    {
        constexpr BlockLength offset = 148;
        constexpr BlockLength length = 12;
 
        return fixedStr<length>(offset, optional);
    }

    ThisType& customerAccountRefId(StrRef value) noexcept
    {
        constexpr BlockLength offset = 148;
        constexpr BlockLength length = 12;
 
        setFixedStr<length>(offset, value);
        return *this;
    }
 
    ThisType& customerAccountRefId(NullOpt) noexcept
    {
        constexpr BlockLength offset = 148;
        constexpr BlockLength length = 12;
 
        setFixedStr<length>(offset, StrRef());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto memo() const noexcept
    {
        constexpr BlockLength offset = 160;
        constexpr BlockLength length = 30;
 
        return fixedStr<length>(offset, optional);
    }

    ThisType& memo(StrRef value) noexcept
    {
        constexpr BlockLength offset = 160;
        constexpr BlockLength length = 30;
 
        setFixedStr<length>(offset, value);
        return *this;
    }
 
    ThisType& memo(NullOpt) noexcept
    {
        constexpr BlockLength offset = 160;
        constexpr BlockLength length = 30;
 
        setFixedStr<length>(offset, StrRef());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto allocationAccount() const noexcept
    {
        constexpr BlockLength offset = 190;
        constexpr BlockLength length = 20;
 
        return fixedStr<length>(offset, optional);
    }

    ThisType& allocationAccount(StrRef value) noexcept
    {
        constexpr BlockLength offset = 190;
        constexpr BlockLength length = 20;
 
        setFixedStr<length>(offset, value);
        return *this;
    }
 
    ThisType& allocationAccount(NullOpt) noexcept
    {
        constexpr BlockLength offset = 190;
        constexpr BlockLength length = 20;
 
        setFixedStr<length>(offset, StrRef());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto onBehalfOfCompId() const noexcept
    {
        constexpr BlockLength offset = 210;
        constexpr BlockLength length = 41;
 
        return fixedStr<length>(offset, optional);
    }

    ThisType& onBehalfOfCompId(StrRef value) noexcept
    {
        constexpr BlockLength offset = 210;
        constexpr BlockLength length = 41;
 
        setFixedStr<length>(offset, value);
        return *this;
    }
 
    ThisType& onBehalfOfCompId(NullOpt) noexcept
    {
        constexpr BlockLength offset = 210;
        constexpr BlockLength length = 41;
 
        setFixedStr<length>(offset, StrRef());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto onBehalfOfSubId() const noexcept
    {
        constexpr BlockLength offset = 251;
        constexpr BlockLength length = 41;
 
        return fixedStr<length>(offset);
    }

    ThisType& onBehalfOfSubId(StrRef value) noexcept
    {
        constexpr BlockLength offset = 251;
        constexpr BlockLength length = 41;
 
        setFixedStr<length>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto onBehalfOfLocationId() const noexcept
    {
        constexpr BlockLength offset = 292;
        constexpr BlockLength length = 41;
 
        return fixedStr<length>(offset);
    }

    ThisType& onBehalfOfLocationId(StrRef value) noexcept
    {
        constexpr BlockLength offset = 292;
        constexpr BlockLength length = 41;
 
        setFixedStr<length>(offset, value);
        return *this;
    }

    constexpr
    static BlockLength minimalBlockLength(ONIXS_ICEBOE_UNUSED SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            333;
    }

    constexpr
    static BlockLength blockLength(SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            minimalBlockLength(version);
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static MessageSize getMinimalVariableFieldsSize(ONIXS_ICEBOE_UNUSED SchemaVersion version)
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            0;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static UInt64 getMaxMessageSize(UInt8) noexcept
    {
        return
            static_cast<UInt64>(MessageHeaderBuilder::Size) +
            blockLength(Schema::Version);
    }

    ThisType& resetVariableFields() noexcept
    {
        return *this;
    }

    ThisType& reset() noexcept
    {
        price(nullOpt);
        manualOrderIndicator(nullOpt);
        maxShow(nullOpt);
        stopPx(nullOpt);
        giveUpClearingFirm(nullOpt);
        selfMatchPreventionId(nullOpt);
        expireDate(nullOpt);
        selfMatchPreventionInstruction(nullOpt);
        execInst(nullOpt);
        directElectronicAccess(nullOpt);
        tradingCapacity(nullOpt);
        liquidityProvision(nullOpt);
        commodityDerivIndicator(nullOpt);
        investmentDecision(nullOpt);
        executionDecision(nullOpt);
        clientIdCode(nullOpt);
        mifidId(nullOpt);
        allocHandlInst(nullOpt);
        priceType(nullOpt);
        customerAccountRefId(nullOpt);
        memo(nullOpt);
        allocationAccount(nullOpt);
        onBehalfOfCompId(nullOpt);
 
        resetVariableFields();
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef className() noexcept
    {
        return constructStrRef("CancelReplaceRequest");
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef fixType() noexcept
    {
        return constructStrRef("G");
    }

    ONIXS_ICEBOE_NODISCARD
    std::string toString() const;

    ONIXS_ICEBOE_NODISCARD
    const void* tail() const noexcept
    {
        return
            toOpaquePtr(
                advanceByBytes(
                    binary(),
                    static_cast<ptrdiff_t>(SbeMessage::blockLength()) +
                        MessageHeader::Size));
    }

    ONIXS_ICEBOE_NODISCARD
    EncodedLength calculateBinarySize() const noexcept
    {
        return
            SbeMessage::calculateBinarySize(tail());
    }
 
private:
    void checkLength(
        EncodedLength length, SchemaVersion version) const
    {
       const EncodedLength minimalRequiredLength =
           minimalBlockLength(version) +
           MessageHeader::Size +
           getMinimalVariableFieldsSize(version);
 
       checkBinaryLength(
           *this, length, minimalRequiredLength);
    }
 
    void checkCompatibility() const
    {
        assert(TemplateId == templateId());
 
        checkSchema<Schema>(schemaId(), version());
        checkLength(bufferSize(), version());
    }
};

struct
CancelRequest
: SbeMessage
{
    typedef SchemaTraits Schema;

    typedef CancelRequest ThisType;

    enum { TemplateId = 6 };

    CancelRequest() = default;

    CancelRequest(void* data, EncodedLength length, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        reset();
    }

    CancelRequest(void* data, EncodedLength length, NoFieldsInit, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        resetVariableFields();
    }

    CancelRequest(void* data, EncodedLength length, NoInit)
      : SbeMessage(data, length)
    {
        checkCompatibility();
    }

    explicit
    CancelRequest(const SbeMessage& message)
      : SbeMessage(message)
    {
        assert(message.valid());
 
        checkCompatibility();
    }

    CancelRequest(void* data, EncodedLength length, NoInit, NoCheck) noexcept
      : SbeMessage(data, length, NoCheck())
    {
        assert(schemaId() == Schema::Id);
        assert(version() >= Schema::MinimalVersion);
        assert(TemplateId == templateId());
    }

    ONIXS_ICEBOE_NODISCARD
    auto symbol() const noexcept
    {
        constexpr BlockLength offset = 0;
 
        return ordinary<Int32>(offset);
    }

    ThisType& symbol(Int32 value) noexcept
    {
        constexpr BlockLength offset = 0;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto originatorUserId() const noexcept
    {
        constexpr BlockLength offset = 4;
        constexpr BlockLength length = 20;
 
        return fixedStr<length>(offset);
    }

    ThisType& originatorUserId(StrRef value) noexcept
    {
        constexpr BlockLength offset = 4;
        constexpr BlockLength length = 20;
 
        setFixedStr<length>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto clOrdId() const noexcept
    {
        constexpr BlockLength offset = 24;
 
        return ordinary<Int64>(offset);
    }

    ThisType& clOrdId(Int64 value) noexcept
    {
        constexpr BlockLength offset = 24;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto origClOrdId() const noexcept
    {
        constexpr BlockLength offset = 32;
 
        return ordinary<Int64>(offset);
    }

    ThisType& origClOrdId(Int64 value) noexcept
    {
        constexpr BlockLength offset = 32;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto side() const noexcept
    {
        constexpr BlockLength offset = 40;
 
        return enumeration<SideEnum>(offset);
    }

    ThisType& side(SideEnum value) noexcept
    {
        constexpr BlockLength offset = 40;
 
        setEnumeration<SideEnum>(offset, value);
        return *this;
    }

    constexpr
    static BlockLength minimalBlockLength(ONIXS_ICEBOE_UNUSED SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            41;
    }

    constexpr
    static BlockLength blockLength(SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            minimalBlockLength(version);
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static MessageSize getMinimalVariableFieldsSize(ONIXS_ICEBOE_UNUSED SchemaVersion version)
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            0;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static UInt64 getMaxMessageSize(UInt8) noexcept
    {
        return
            static_cast<UInt64>(MessageHeaderBuilder::Size) +
            blockLength(Schema::Version);
    }

    ThisType& resetVariableFields() noexcept
    {
        return *this;
    }

    ThisType& reset() noexcept
    {
        resetVariableFields();
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef className() noexcept
    {
        return constructStrRef("CancelRequest");
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef fixType() noexcept
    {
        return constructStrRef("F");
    }

    ONIXS_ICEBOE_NODISCARD
    std::string toString() const;

    ONIXS_ICEBOE_NODISCARD
    const void* tail() const noexcept
    {
        return
            toOpaquePtr(
                advanceByBytes(
                    binary(),
                    static_cast<ptrdiff_t>(SbeMessage::blockLength()) +
                        MessageHeader::Size));
    }

    ONIXS_ICEBOE_NODISCARD
    EncodedLength calculateBinarySize() const noexcept
    {
        return
            SbeMessage::calculateBinarySize(tail());
    }
 
private:
    void checkLength(
        EncodedLength length, SchemaVersion version) const
    {
       const EncodedLength minimalRequiredLength =
           minimalBlockLength(version) +
           MessageHeader::Size +
           getMinimalVariableFieldsSize(version);
 
       checkBinaryLength(
           *this, length, minimalRequiredLength);
    }
 
    void checkCompatibility() const
    {
        assert(TemplateId == templateId());
 
        checkSchema<Schema>(schemaId(), version());
        checkLength(bufferSize(), version());
    }
};

struct
QuoteRequest
: SbeMessage
{
    typedef SchemaTraits Schema;

    typedef QuoteRequest ThisType;

    enum { TemplateId = 7 };

    QuoteRequest() = default;

    QuoteRequest(void* data, EncodedLength length, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        reset();
    }

    QuoteRequest(void* data, EncodedLength length, NoFieldsInit, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        resetVariableFields();
    }

    QuoteRequest(void* data, EncodedLength length, NoInit)
      : SbeMessage(data, length)
    {
        checkCompatibility();
    }

    explicit
    QuoteRequest(const SbeMessage& message)
      : SbeMessage(message)
    {
        assert(message.valid());
 
        checkCompatibility();
    }

    QuoteRequest(void* data, EncodedLength length, NoInit, NoCheck) noexcept
      : SbeMessage(data, length, NoCheck())
    {
        assert(schemaId() == Schema::Id);
        assert(version() >= Schema::MinimalVersion);
        assert(TemplateId == templateId());
    }

    ONIXS_ICEBOE_NODISCARD
    auto originatorUserId() const noexcept
    {
        constexpr BlockLength offset = 0;
        constexpr BlockLength length = 20;
 
        return fixedStr<length>(offset);
    }

    ThisType& originatorUserId(StrRef value) noexcept
    {
        constexpr BlockLength offset = 0;
        constexpr BlockLength length = 20;
 
        setFixedStr<length>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto side() const noexcept
    {
        constexpr BlockLength offset = 20;
 
        return enumeration<SideEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& side(SideEnum value) noexcept
    {
        constexpr BlockLength offset = 20;
 
        setEnumeration<SideEnum>(offset, value);
        return *this;
    }
 
    ThisType& side(NullOpt) noexcept
    {
        constexpr BlockLength offset = 20;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto orderQty() const noexcept
    {
        constexpr BlockLength offset = 21;
 
        return ordinary<NullDecimal9>(offset, optional);
    }

    ThisType& orderQty(Decimal9 value) noexcept
    {
        constexpr BlockLength offset = 21;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& orderQty(NullOpt) noexcept
    {
        constexpr BlockLength offset = 21;
 
        setOrdinary(offset, NullDecimal9());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto rfqReqId() const noexcept
    {
        constexpr BlockLength offset = 29;
 
        return ordinary<Int64>(offset);
    }

    ThisType& rfqReqId(Int64 value) noexcept
    {
        constexpr BlockLength offset = 29;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto symbol() const noexcept
    {
        constexpr BlockLength offset = 37;
 
        return ordinary<Int32>(offset);
    }

    ThisType& symbol(Int32 value) noexcept
    {
        constexpr BlockLength offset = 37;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto clearingFirm() const noexcept
    {
        constexpr BlockLength offset = 41;
 
        return ordinary<NullInt32NULL>(offset, optional);
    }

    ThisType& clearingFirm(Int32NULL value) noexcept
    {
        constexpr BlockLength offset = 41;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& clearingFirm(NullOpt) noexcept
    {
        constexpr BlockLength offset = 41;
 
        setOrdinary(offset, NullInt32NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto clearingAccount() const noexcept
    {
        constexpr BlockLength offset = 45;
        constexpr BlockLength length = 14;
 
        return fixedStr<length>(offset, optional);
    }

    ThisType& clearingAccount(StrRef value) noexcept
    {
        constexpr BlockLength offset = 45;
        constexpr BlockLength length = 14;
 
        setFixedStr<length>(offset, value);
        return *this;
    }
 
    ThisType& clearingAccount(NullOpt) noexcept
    {
        constexpr BlockLength offset = 45;
        constexpr BlockLength length = 14;
 
        setFixedStr<length>(offset, StrRef());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto onBehalfOfCompId() const noexcept
    {
        constexpr BlockLength offset = 59;
        constexpr BlockLength length = 41;
 
        return fixedStr<length>(offset, optional);
    }

    ThisType& onBehalfOfCompId(StrRef value) noexcept
    {
        constexpr BlockLength offset = 59;
        constexpr BlockLength length = 41;
 
        setFixedStr<length>(offset, value);
        return *this;
    }
 
    ThisType& onBehalfOfCompId(NullOpt) noexcept
    {
        constexpr BlockLength offset = 59;
        constexpr BlockLength length = 41;
 
        setFixedStr<length>(offset, StrRef());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto onBehalfOfSubId() const noexcept
    {
        constexpr BlockLength offset = 100;
        constexpr BlockLength length = 41;
 
        return fixedStr<length>(offset);
    }

    ThisType& onBehalfOfSubId(StrRef value) noexcept
    {
        constexpr BlockLength offset = 100;
        constexpr BlockLength length = 41;
 
        setFixedStr<length>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto onBehalfOfLocationId() const noexcept
    {
        constexpr BlockLength offset = 141;
        constexpr BlockLength length = 41;
 
        return fixedStr<length>(offset);
    }

    ThisType& onBehalfOfLocationId(StrRef value) noexcept
    {
        constexpr BlockLength offset = 141;
        constexpr BlockLength length = 41;
 
        setFixedStr<length>(offset, value);
        return *this;
    }

    constexpr
    static BlockLength minimalBlockLength(ONIXS_ICEBOE_UNUSED SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            182;
    }

    constexpr
    static BlockLength blockLength(SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            minimalBlockLength(version);
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static MessageSize getMinimalVariableFieldsSize(ONIXS_ICEBOE_UNUSED SchemaVersion version)
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            0;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static UInt64 getMaxMessageSize(UInt8) noexcept
    {
        return
            static_cast<UInt64>(MessageHeaderBuilder::Size) +
            blockLength(Schema::Version);
    }

    ThisType& resetVariableFields() noexcept
    {
        return *this;
    }

    ThisType& reset() noexcept
    {
        side(nullOpt);
        orderQty(nullOpt);
        clearingFirm(nullOpt);
        clearingAccount(nullOpt);
        onBehalfOfCompId(nullOpt);
 
        resetVariableFields();
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef className() noexcept
    {
        return constructStrRef("QuoteRequest");
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef fixType() noexcept
    {
        return constructStrRef("R");
    }

    ONIXS_ICEBOE_NODISCARD
    std::string toString() const;

    ONIXS_ICEBOE_NODISCARD
    const void* tail() const noexcept
    {
        return
            toOpaquePtr(
                advanceByBytes(
                    binary(),
                    static_cast<ptrdiff_t>(SbeMessage::blockLength()) +
                        MessageHeader::Size));
    }

    ONIXS_ICEBOE_NODISCARD
    EncodedLength calculateBinarySize() const noexcept
    {
        return
            SbeMessage::calculateBinarySize(tail());
    }
 
private:
    void checkLength(
        EncodedLength length, SchemaVersion version) const
    {
       const EncodedLength minimalRequiredLength =
           minimalBlockLength(version) +
           MessageHeader::Size +
           getMinimalVariableFieldsSize(version);
 
       checkBinaryLength(
           *this, length, minimalRequiredLength);
    }
 
    void checkCompatibility() const
    {
        assert(TemplateId == templateId());
 
        checkSchema<Schema>(schemaId(), version());
        checkLength(bufferSize(), version());
    }
};

struct
NewOrderCrossRequest
: SbeMessage
{
    typedef SchemaTraits Schema;

    typedef NewOrderCrossRequest ThisType;

    enum { TemplateId = 8 };

    struct
    SidesEntry : SbeGroupEntry
    <
        GroupSizeEncoding::BlockLength
    >
    {
        typedef
        SbeGroupEntry
        <
            GroupSizeEncoding::BlockLength
        >
        Base;

        typedef SidesEntry ThisType;

        SidesEntry(void* data, EncodedLength length, SchemaVersion version)
          : Base(data, numericCast<Base::BlockLength>(length), version)
        {
            assert(version >= Schema::MinimalVersion);
            assert(length >= minimalBlockLength(version));
        }

        ThisType& resetVariableFields() noexcept
        {
            return *this;
        }

        ThisType& reset() noexcept
        {
            giveUpClearingFirm(nullOpt);
            directElectronicAccess(nullOpt);
            tradingCapacity(nullOpt);
            liquidityProvision(nullOpt);
            commodityDerivIndicator(nullOpt);
            investmentDecision(nullOpt);
            executionDecision(nullOpt);
            clientIdCode(nullOpt);
            mifidId(nullOpt);
            selfMatchPreventionId(nullOpt);
            selfMatchPreventionInstruction(nullOpt);
            manualOrderIndicator(nullOpt);
            custOrderHandlingInst(nullOpt);
            positionEffect(nullOpt);
            allocHandlInst(nullOpt);
            customerAccountRefId(nullOpt);
            memo(nullOpt);
            allocationAccount(nullOpt);
            onBehalfOfCompId(nullOpt);
 
            resetVariableFields();
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto side() const noexcept
        {
            constexpr BlockLength offset = 0;
 
            return enumeration<SideEnum>(offset);
        }

        ThisType& side(SideEnum value) noexcept
        {
            constexpr BlockLength offset = 0;
 
            setEnumeration<SideEnum>(offset, value);
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto clOrdId() const noexcept
        {
            constexpr BlockLength offset = 1;
 
            return ordinary<Int64>(offset);
        }

        ThisType& clOrdId(Int64 value) noexcept
        {
            constexpr BlockLength offset = 1;
 
            setOrdinary(offset, value);
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto giveUpClearingFirm() const noexcept
        {
            constexpr BlockLength offset = 9;
 
            return ordinary<NullInt32NULL>(offset, optional);
        }

        ThisType& giveUpClearingFirm(Int32NULL value) noexcept
        {
            constexpr BlockLength offset = 9;
 
            setOrdinary(offset, value);
            return *this;
        }
 
        ThisType& giveUpClearingFirm(NullOpt) noexcept
        {
            constexpr BlockLength offset = 9;
 
            setOrdinary(offset, NullInt32NULL());
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto clearingFirm() const noexcept
        {
            constexpr BlockLength offset = 13;
 
            return ordinary<Int32>(offset);
        }

        ThisType& clearingFirm(Int32 value) noexcept
        {
            constexpr BlockLength offset = 13;
 
            setOrdinary(offset, value);
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto directElectronicAccess() const noexcept
        {
            constexpr BlockLength offset = 17;
 
            return enumeration<BooleanEnum, NullUint8NULL>(offset, optional);
        }

        ThisType& directElectronicAccess(BooleanEnum value) noexcept
        {
            constexpr BlockLength offset = 17;
 
            setEnumeration<BooleanEnum>(offset, value);
            return *this;
        }
 
        ThisType& directElectronicAccess(NullOpt) noexcept
        {
            constexpr BlockLength offset = 17;
 
            setOrdinary(offset, NullUint8NULL());
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto tradingCapacity() const noexcept
        {
            constexpr BlockLength offset = 18;
 
            return enumeration<TradingCapacityEnum, NullUint8NULL>(offset, optional);
        }

        ThisType& tradingCapacity(TradingCapacityEnum value) noexcept
        {
            constexpr BlockLength offset = 18;
 
            setEnumeration<TradingCapacityEnum>(offset, value);
            return *this;
        }
 
        ThisType& tradingCapacity(NullOpt) noexcept
        {
            constexpr BlockLength offset = 18;
 
            setOrdinary(offset, NullUint8NULL());
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto liquidityProvision() const noexcept
        {
            constexpr BlockLength offset = 19;
 
            return enumeration<BooleanEnum, NullUint8NULL>(offset, optional);
        }

        ThisType& liquidityProvision(BooleanEnum value) noexcept
        {
            constexpr BlockLength offset = 19;
 
            setEnumeration<BooleanEnum>(offset, value);
            return *this;
        }
 
        ThisType& liquidityProvision(NullOpt) noexcept
        {
            constexpr BlockLength offset = 19;
 
            setOrdinary(offset, NullUint8NULL());
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto commodityDerivIndicator() const noexcept
        {
            constexpr BlockLength offset = 20;
 
            return enumeration<BooleanEnum, NullUint8NULL>(offset, optional);
        }

        ThisType& commodityDerivIndicator(BooleanEnum value) noexcept
        {
            constexpr BlockLength offset = 20;
 
            setEnumeration<BooleanEnum>(offset, value);
            return *this;
        }
 
        ThisType& commodityDerivIndicator(NullOpt) noexcept
        {
            constexpr BlockLength offset = 20;
 
            setOrdinary(offset, NullUint8NULL());
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto investmentDecision() const noexcept
        {
            constexpr BlockLength offset = 21;
 
            return ordinary<NullInt64NULL>(offset, optional);
        }

        ThisType& investmentDecision(Int64NULL value) noexcept
        {
            constexpr BlockLength offset = 21;
 
            setOrdinary(offset, value);
            return *this;
        }
 
        ThisType& investmentDecision(NullOpt) noexcept
        {
            constexpr BlockLength offset = 21;
 
            setOrdinary(offset, NullInt64NULL());
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto executionDecision() const noexcept
        {
            constexpr BlockLength offset = 29;
 
            return ordinary<NullInt64NULL>(offset, optional);
        }

        ThisType& executionDecision(Int64NULL value) noexcept
        {
            constexpr BlockLength offset = 29;
 
            setOrdinary(offset, value);
            return *this;
        }
 
        ThisType& executionDecision(NullOpt) noexcept
        {
            constexpr BlockLength offset = 29;
 
            setOrdinary(offset, NullInt64NULL());
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto clientIdCode() const noexcept
        {
            constexpr BlockLength offset = 37;
 
            return ordinary<NullInt64NULL>(offset, optional);
        }

        ThisType& clientIdCode(Int64NULL value) noexcept
        {
            constexpr BlockLength offset = 37;
 
            setOrdinary(offset, value);
            return *this;
        }
 
        ThisType& clientIdCode(NullOpt) noexcept
        {
            constexpr BlockLength offset = 37;
 
            setOrdinary(offset, NullInt64NULL());
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto mifidId() const noexcept
        {
            constexpr BlockLength offset = 45;
 
            return ordinary<NullInt64NULL>(offset, optional);
        }

        ThisType& mifidId(Int64NULL value) noexcept
        {
            constexpr BlockLength offset = 45;
 
            setOrdinary(offset, value);
            return *this;
        }
 
        ThisType& mifidId(NullOpt) noexcept
        {
            constexpr BlockLength offset = 45;
 
            setOrdinary(offset, NullInt64NULL());
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto selfMatchPreventionId() const noexcept
        {
            constexpr BlockLength offset = 53;
 
            return ordinary<NullInt64NULL>(offset, optional);
        }

        ThisType& selfMatchPreventionId(Int64NULL value) noexcept
        {
            constexpr BlockLength offset = 53;
 
            setOrdinary(offset, value);
            return *this;
        }
 
        ThisType& selfMatchPreventionId(NullOpt) noexcept
        {
            constexpr BlockLength offset = 53;
 
            setOrdinary(offset, NullInt64NULL());
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto selfMatchPreventionInstruction() const noexcept
        {
            constexpr BlockLength offset = 61;
 
            return enumeration<SelfMatchPreventionInstructionEnum, NullCharType>(offset, optional);
        }

        ThisType& selfMatchPreventionInstruction(SelfMatchPreventionInstructionEnum value) noexcept
        {
            constexpr BlockLength offset = 61;
 
            setEnumeration<SelfMatchPreventionInstructionEnum>(offset, value);
            return *this;
        }
 
        ThisType& selfMatchPreventionInstruction(NullOpt) noexcept
        {
            constexpr BlockLength offset = 61;
 
            setOrdinary(offset, NullCharType());
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto manualOrderIndicator() const noexcept
        {
            constexpr BlockLength offset = 62;
 
            return enumeration<BooleanEnum, NullUint8NULL>(offset, optional);
        }

        ThisType& manualOrderIndicator(BooleanEnum value) noexcept
        {
            constexpr BlockLength offset = 62;
 
            setEnumeration<BooleanEnum>(offset, value);
            return *this;
        }
 
        ThisType& manualOrderIndicator(NullOpt) noexcept
        {
            constexpr BlockLength offset = 62;
 
            setOrdinary(offset, NullUint8NULL());
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto custOrderHandlingInst() const noexcept
        {
            constexpr BlockLength offset = 63;
 
            return enumeration<CustOrderHandlingInstEnum, NullCharType>(offset, optional);
        }

        ThisType& custOrderHandlingInst(CustOrderHandlingInstEnum value) noexcept
        {
            constexpr BlockLength offset = 63;
 
            setEnumeration<CustOrderHandlingInstEnum>(offset, value);
            return *this;
        }
 
        ThisType& custOrderHandlingInst(NullOpt) noexcept
        {
            constexpr BlockLength offset = 63;
 
            setOrdinary(offset, NullCharType());
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto positionEffect() const noexcept
        {
            constexpr BlockLength offset = 64;
 
            return enumeration<PositionEffectEnum, NullCharType>(offset, optional);
        }

        ThisType& positionEffect(PositionEffectEnum value) noexcept
        {
            constexpr BlockLength offset = 64;
 
            setEnumeration<PositionEffectEnum>(offset, value);
            return *this;
        }
 
        ThisType& positionEffect(NullOpt) noexcept
        {
            constexpr BlockLength offset = 64;
 
            setOrdinary(offset, NullCharType());
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto allocHandlInst() const noexcept
        {
            constexpr BlockLength offset = 65;
 
            return enumeration<AllocHandlInstEnum, NullCharType>(offset, optional);
        }

        ThisType& allocHandlInst(AllocHandlInstEnum value) noexcept
        {
            constexpr BlockLength offset = 65;
 
            setEnumeration<AllocHandlInstEnum>(offset, value);
            return *this;
        }
 
        ThisType& allocHandlInst(NullOpt) noexcept
        {
            constexpr BlockLength offset = 65;
 
            setOrdinary(offset, NullCharType());
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto clearingAccount() const noexcept
        {
            constexpr BlockLength offset = 66;
            constexpr BlockLength length = 14;
 
            return fixedStr<length>(offset);
        }

        ThisType& clearingAccount(StrRef value) noexcept
        {
            constexpr BlockLength offset = 66;
            constexpr BlockLength length = 14;
 
            setFixedStr<length>(offset, value);
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto customerAccountRefId() const noexcept
        {
            constexpr BlockLength offset = 80;
            constexpr BlockLength length = 12;
 
            return fixedStr<length>(offset, optional);
        }

        ThisType& customerAccountRefId(StrRef value) noexcept
        {
            constexpr BlockLength offset = 80;
            constexpr BlockLength length = 12;
 
            setFixedStr<length>(offset, value);
            return *this;
        }
 
        ThisType& customerAccountRefId(NullOpt) noexcept
        {
            constexpr BlockLength offset = 80;
            constexpr BlockLength length = 12;
 
            setFixedStr<length>(offset, StrRef());
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto memo() const noexcept
        {
            constexpr BlockLength offset = 92;
            constexpr BlockLength length = 30;
 
            return fixedStr<length>(offset, optional);
        }

        ThisType& memo(StrRef value) noexcept
        {
            constexpr BlockLength offset = 92;
            constexpr BlockLength length = 30;
 
            setFixedStr<length>(offset, value);
            return *this;
        }
 
        ThisType& memo(NullOpt) noexcept
        {
            constexpr BlockLength offset = 92;
            constexpr BlockLength length = 30;
 
            setFixedStr<length>(offset, StrRef());
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto allocationAccount() const noexcept
        {
            constexpr BlockLength offset = 122;
            constexpr BlockLength length = 20;
 
            return fixedStr<length>(offset, optional);
        }

        ThisType& allocationAccount(StrRef value) noexcept
        {
            constexpr BlockLength offset = 122;
            constexpr BlockLength length = 20;
 
            setFixedStr<length>(offset, value);
            return *this;
        }
 
        ThisType& allocationAccount(NullOpt) noexcept
        {
            constexpr BlockLength offset = 122;
            constexpr BlockLength length = 20;
 
            setFixedStr<length>(offset, StrRef());
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto onBehalfOfCompId() const noexcept
        {
            constexpr BlockLength offset = 142;
            constexpr BlockLength length = 41;
 
            return fixedStr<length>(offset, optional);
        }

        ThisType& onBehalfOfCompId(StrRef value) noexcept
        {
            constexpr BlockLength offset = 142;
            constexpr BlockLength length = 41;
 
            setFixedStr<length>(offset, value);
            return *this;
        }
 
        ThisType& onBehalfOfCompId(NullOpt) noexcept
        {
            constexpr BlockLength offset = 142;
            constexpr BlockLength length = 41;
 
            setFixedStr<length>(offset, StrRef());
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto onBehalfOfSubId() const noexcept
        {
            constexpr BlockLength offset = 183;
            constexpr BlockLength length = 41;
 
            return fixedStr<length>(offset);
        }

        ThisType& onBehalfOfSubId(StrRef value) noexcept
        {
            constexpr BlockLength offset = 183;
            constexpr BlockLength length = 41;
 
            setFixedStr<length>(offset, value);
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto onBehalfOfLocationId() const noexcept
        {
            constexpr BlockLength offset = 224;
            constexpr BlockLength length = 41;
 
            return fixedStr<length>(offset);
        }

        ThisType& onBehalfOfLocationId(StrRef value) noexcept
        {
            constexpr BlockLength offset = 224;
            constexpr BlockLength length = 41;
 
            setFixedStr<length>(offset, value);
            return *this;
        }

        constexpr
        static BlockLength blockLength(SchemaVersion version) noexcept
        {
            return
                ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
                minimalBlockLength(version);
        }

        constexpr
        static BlockLength minimalBlockLength(ONIXS_ICEBOE_UNUSED SchemaVersion version) noexcept
        {
            return
                ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
                265;
        }

        ONIXS_ICEBOE_NODISCARD
        constexpr
        static StrRef className() noexcept
        {
            return constructStrRef("NewOrderCrossRequest.SidesEntry");
        }
    };

    typedef
    SbeGroup<SidesEntry, GroupSizeEncoding, MessageSize>
    Sides;

    struct
    LegsEntry : SbeGroupEntry
    <
        GroupSizeEncoding::BlockLength
    >
    {
        typedef
        SbeGroupEntry
        <
            GroupSizeEncoding::BlockLength
        >
        Base;

        typedef LegsEntry ThisType;

        LegsEntry(void* data, EncodedLength length, SchemaVersion version)
          : Base(data, numericCast<Base::BlockLength>(length), version)
        {
            assert(version >= Schema::MinimalVersion);
            assert(length >= minimalBlockLength(version));
        }

        ThisType& resetVariableFields() noexcept
        {
            return *this;
        }

        ThisType& reset() noexcept
        {
            legSymbol(nullOpt);
            legSecurityIdSource(nullOpt);
            legOptAttribute(nullOpt);
            legQty(nullOpt);
            legPrice(nullOpt);
            legMemoField(nullOpt);
            legSecurityId(nullOpt);
 
            resetVariableFields();
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto legSymbol() const noexcept
        {
            constexpr BlockLength offset = 0;
 
            return ordinary<NullInt32NULL>(offset, optional);
        }

        ThisType& legSymbol(Int32NULL value) noexcept
        {
            constexpr BlockLength offset = 0;
 
            setOrdinary(offset, value);
            return *this;
        }
 
        ThisType& legSymbol(NullOpt) noexcept
        {
            constexpr BlockLength offset = 0;
 
            setOrdinary(offset, NullInt32NULL());
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto legSecurityIdSource() const noexcept
        {
            constexpr BlockLength offset = 4;
 
            return ordinary<NullInt8NULL>(offset, optional);
        }

        ThisType& legSecurityIdSource(Int8NULL value) noexcept
        {
            constexpr BlockLength offset = 4;
 
            setOrdinary(offset, value);
            return *this;
        }
 
        ThisType& legSecurityIdSource(NullOpt) noexcept
        {
            constexpr BlockLength offset = 4;
 
            setOrdinary(offset, NullInt8NULL());
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto legOptAttribute() const noexcept
        {
            constexpr BlockLength offset = 5;
 
            return ordinary<NullInt32NULL>(offset, optional);
        }

        ThisType& legOptAttribute(Int32NULL value) noexcept
        {
            constexpr BlockLength offset = 5;
 
            setOrdinary(offset, value);
            return *this;
        }
 
        ThisType& legOptAttribute(NullOpt) noexcept
        {
            constexpr BlockLength offset = 5;
 
            setOrdinary(offset, NullInt32NULL());
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto legQty() const noexcept
        {
            constexpr BlockLength offset = 9;
 
            return ordinary<NullDecimal9>(offset, optional);
        }

        ThisType& legQty(Decimal9 value) noexcept
        {
            constexpr BlockLength offset = 9;
 
            setOrdinary(offset, value);
            return *this;
        }
 
        ThisType& legQty(NullOpt) noexcept
        {
            constexpr BlockLength offset = 9;
 
            setOrdinary(offset, NullDecimal9());
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto legPrice() const noexcept
        {
            constexpr BlockLength offset = 17;
 
            return ordinary<NullDecimal9>(offset, optional);
        }

        ThisType& legPrice(Decimal9 value) noexcept
        {
            constexpr BlockLength offset = 17;
 
            setOrdinary(offset, value);
            return *this;
        }
 
        ThisType& legPrice(NullOpt) noexcept
        {
            constexpr BlockLength offset = 17;
 
            setOrdinary(offset, NullDecimal9());
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto legSecurityType() const noexcept
        {
            constexpr BlockLength offset = 25;
 
            return enumeration<SecurityTypeEnum>(offset);
        }

        ThisType& legSecurityType(SecurityTypeEnum value) noexcept
        {
            constexpr BlockLength offset = 25;
 
            setEnumeration<SecurityTypeEnum>(offset, value);
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto legMemoField() const noexcept
        {
            constexpr BlockLength offset = 26;
            constexpr BlockLength length = 12;
 
            return fixedStr<length>(offset, optional);
        }

        ThisType& legMemoField(StrRef value) noexcept
        {
            constexpr BlockLength offset = 26;
            constexpr BlockLength length = 12;
 
            setFixedStr<length>(offset, value);
            return *this;
        }
 
        ThisType& legMemoField(NullOpt) noexcept
        {
            constexpr BlockLength offset = 26;
            constexpr BlockLength length = 12;
 
            setFixedStr<length>(offset, StrRef());
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto legSecurityId() const noexcept
        {
            constexpr BlockLength offset = 38;
            constexpr BlockLength length = 75;
 
            return fixedStr<length>(offset, optional);
        }

        ThisType& legSecurityId(StrRef value) noexcept
        {
            constexpr BlockLength offset = 38;
            constexpr BlockLength length = 75;
 
            setFixedStr<length>(offset, value);
            return *this;
        }
 
        ThisType& legSecurityId(NullOpt) noexcept
        {
            constexpr BlockLength offset = 38;
            constexpr BlockLength length = 75;
 
            setFixedStr<length>(offset, StrRef());
            return *this;
        }

        constexpr
        static BlockLength blockLength(SchemaVersion version) noexcept
        {
            return
                ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
                minimalBlockLength(version);
        }

        constexpr
        static BlockLength minimalBlockLength(ONIXS_ICEBOE_UNUSED SchemaVersion version) noexcept
        {
            return
                ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
                113;
        }

        ONIXS_ICEBOE_NODISCARD
        constexpr
        static StrRef className() noexcept
        {
            return constructStrRef("NewOrderCrossRequest.LegsEntry");
        }
    };

    typedef
    SbeGroup<LegsEntry, GroupSizeEncoding, MessageSize>
    Legs;

    NewOrderCrossRequest() = default;

    NewOrderCrossRequest(void* data, EncodedLength length, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        reset();
    }

    NewOrderCrossRequest(void* data, EncodedLength length, NoFieldsInit, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        resetVariableFields();
    }

    NewOrderCrossRequest(void* data, EncodedLength length, NoInit)
      : SbeMessage(data, length)
    {
        checkCompatibility();
    }

    explicit
    NewOrderCrossRequest(const SbeMessage& message)
      : SbeMessage(message)
    {
        assert(message.valid());
 
        checkCompatibility();
    }

    NewOrderCrossRequest(void* data, EncodedLength length, NoInit, NoCheck) noexcept
      : SbeMessage(data, length, NoCheck())
    {
        assert(schemaId() == Schema::Id);
        assert(version() >= Schema::MinimalVersion);
        assert(TemplateId == templateId());
    }

    ONIXS_ICEBOE_NODISCARD
    auto price() const noexcept
    {
        constexpr BlockLength offset = 0;
 
        return ordinary<Decimal9>(offset);
    }

    ThisType& price(Decimal9 value) noexcept
    {
        constexpr BlockLength offset = 0;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto orderQty() const noexcept
    {
        constexpr BlockLength offset = 8;
 
        return ordinary<Decimal9>(offset);
    }

    ThisType& orderQty(Decimal9 value) noexcept
    {
        constexpr BlockLength offset = 8;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto symbol() const noexcept
    {
        constexpr BlockLength offset = 16;
 
        return ordinary<Int32>(offset);
    }

    ThisType& symbol(Int32 value) noexcept
    {
        constexpr BlockLength offset = 16;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto originatorUserId() const noexcept
    {
        constexpr BlockLength offset = 20;
        constexpr BlockLength length = 20;
 
        return fixedStr<length>(offset);
    }

    ThisType& originatorUserId(StrRef value) noexcept
    {
        constexpr BlockLength offset = 20;
        constexpr BlockLength length = 20;
 
        setFixedStr<length>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto ordType() const noexcept
    {
        constexpr BlockLength offset = 40;
 
        return enumeration<OrderTypeEnum>(offset);
    }

    ThisType& ordType(OrderTypeEnum value) noexcept
    {
        constexpr BlockLength offset = 40;
 
        setEnumeration<OrderTypeEnum>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto crossId() const noexcept
    {
        constexpr BlockLength offset = 41;
 
        return ordinary<Int64>(offset);
    }

    ThisType& crossId(Int64 value) noexcept
    {
        constexpr BlockLength offset = 41;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto crossType() const noexcept
    {
        constexpr BlockLength offset = 49;
 
        return enumeration<CrossTypeEnum>(offset);
    }

    ThisType& crossType(CrossTypeEnum value) noexcept
    {
        constexpr BlockLength offset = 49;
 
        setEnumeration<CrossTypeEnum>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto tradeType() const noexcept
    {
        constexpr BlockLength offset = 50;
        constexpr BlockLength length = 3;
 
        return fixedStr<length>(offset, optional);
    }

    ThisType& tradeType(StrRef value) noexcept
    {
        constexpr BlockLength offset = 50;
        constexpr BlockLength length = 3;
 
        setFixedStr<length>(offset, value);
        return *this;
    }
 
    ThisType& tradeType(NullOpt) noexcept
    {
        constexpr BlockLength offset = 50;
        constexpr BlockLength length = 3;
 
        setFixedStr<length>(offset, StrRef());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto execInst() const noexcept
    {
        constexpr BlockLength offset = 53;
 
        return enumeration<ExecInstEnum, NullCharType>(offset, optional);
    }

    ThisType& execInst(ExecInstEnum value) noexcept
    {
        constexpr BlockLength offset = 53;
 
        setEnumeration<ExecInstEnum>(offset, value);
        return *this;
    }
 
    ThisType& execInst(NullOpt) noexcept
    {
        constexpr BlockLength offset = 53;
 
        setOrdinary(offset, NullCharType());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto priceType() const noexcept
    {
        constexpr BlockLength offset = 54;
 
        return enumeration<PriceTypeEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& priceType(PriceTypeEnum value) noexcept
    {
        constexpr BlockLength offset = 54;
 
        setEnumeration<PriceTypeEnum>(offset, value);
        return *this;
    }
 
    ThisType& priceType(NullOpt) noexcept
    {
        constexpr BlockLength offset = 54;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto bypassMQR() const noexcept
    {
        constexpr BlockLength offset = 55;
 
        return enumeration<BooleanEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& bypassMQR(BooleanEnum value) noexcept
    {
        constexpr BlockLength offset = 55;
 
        setEnumeration<BooleanEnum>(offset, value);
        return *this;
    }
 
    ThisType& bypassMQR(NullOpt) noexcept
    {
        constexpr BlockLength offset = 55;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto hedgeOnly() const noexcept
    {
        constexpr BlockLength offset = 56;
 
        return enumeration<BooleanEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& hedgeOnly(BooleanEnum value) noexcept
    {
        constexpr BlockLength offset = 56;
 
        setEnumeration<BooleanEnum>(offset, value);
        return *this;
    }
 
    ThisType& hedgeOnly(NullOpt) noexcept
    {
        constexpr BlockLength offset = 56;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto benchmarkPrice() const noexcept
    {
        constexpr BlockLength offset = 57;
 
        return ordinary<NullDecimal9>(offset, optional);
    }

    ThisType& benchmarkPrice(Decimal9 value) noexcept
    {
        constexpr BlockLength offset = 57;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& benchmarkPrice(NullOpt) noexcept
    {
        constexpr BlockLength offset = 57;
 
        setOrdinary(offset, NullDecimal9());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto benchMarkPriceType() const noexcept
    {
        constexpr BlockLength offset = 65;
 
        return enumeration<BenchmarkPriceTypeEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& benchMarkPriceType(BenchmarkPriceTypeEnum value) noexcept
    {
        constexpr BlockLength offset = 65;
 
        setEnumeration<BenchmarkPriceTypeEnum>(offset, value);
        return *this;
    }
 
    ThisType& benchMarkPriceType(NullOpt) noexcept
    {
        constexpr BlockLength offset = 65;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto timeInForce() const noexcept
    {
        constexpr BlockLength offset = 66;
 
        return enumeration<TimeInForceEnum>(offset);
    }

    ThisType& timeInForce(TimeInForceEnum value) noexcept
    {
        constexpr BlockLength offset = 66;
 
        setEnumeration<TimeInForceEnum>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto transactDetails() const noexcept
    {
        constexpr BlockLength offset = 67;
        constexpr BlockLength length = 100;
 
        return fixedStr<length>(offset, optional);
    }

    ThisType& transactDetails(StrRef value) noexcept
    {
        constexpr BlockLength offset = 67;
        constexpr BlockLength length = 100;
 
        setFixedStr<length>(offset, value);
        return *this;
    }
 
    ThisType& transactDetails(NullOpt) noexcept
    {
        constexpr BlockLength offset = 67;
        constexpr BlockLength length = 100;
 
        setFixedStr<length>(offset, StrRef());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto transactTime() const noexcept(ticksToTimestamp::Nothrow)
    {
        constexpr BlockLength offset = 167;
        return convertible<ticksToTimestamp>(offset);
    }

    ThisType& transactTime(Timestamp value) noexcept(timestampToTicks::Nothrow)
    {
        constexpr BlockLength offset = 167;
 
        setOrdinary(offset, convert<timestampToTicks>(value));
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    Sides sides() const noexcept
    {
        return getGroup<Sides>(SidesAccess(), *this);
    }

    ONIXS_ICEBOE_NODISCARD
    Sides sides() noexcept
    {
        return getGroup<Sides>(SidesAccess(), *this);
    }

    Sides sides(Sides::Size length)
    {
        return constructGroup<Sides>(
            SidesAccess(),
            length,
            *this);
    }

    Sides sides(Sides::Size length, NoFieldsInit)
    {
        return setupGroup<Sides>(
            SidesAccess(),
            length,
            *this);
    }

    ONIXS_ICEBOE_NODISCARD
    Legs legs() const noexcept
    {
        return getGroup<Legs>(LegsAccess(), *this);
    }

    ONIXS_ICEBOE_NODISCARD
    Legs legs() noexcept
    {
        return getGroup<Legs>(LegsAccess(), *this);
    }

    Legs legs(Legs::Size length)
    {
        return constructGroup<Legs>(
            LegsAccess(),
            length,
            *this);
    }

    Legs legs(Legs::Size length, NoFieldsInit)
    {
        return setupGroup<Legs>(
            LegsAccess(),
            length,
            *this);
    }

    constexpr
    static BlockLength minimalBlockLength(ONIXS_ICEBOE_UNUSED SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            175;
    }

    constexpr
    static BlockLength blockLength(SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            minimalBlockLength(version);
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static MessageSize getMinimalVariableFieldsSize(ONIXS_ICEBOE_UNUSED SchemaVersion version)
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            static_cast<MessageSize>(Sides::EmptySize) + static_cast<MessageSize>(Legs::EmptySize);
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static UInt64 getMaxMessageSize(UInt8 maxGroupItems = 255) noexcept
    {
        return
            static_cast<UInt64>(MessageHeaderBuilder::Size) +
            blockLength(Schema::Version) +
            (GroupSizeEncoding::Size + SidesEntry::blockLength(Schema::Version) * static_cast<UInt64>(maxGroupItems)) +
            (GroupSizeEncoding::Size + LegsEntry::blockLength(Schema::Version) * static_cast<UInt64>(maxGroupItems));
    }

    ThisType& resetVariableFields() noexcept
    {
        sides(nullOpt);
        legs(nullOpt);
        return *this;
    }

    ThisType& reset() noexcept
    {
        tradeType(nullOpt);
        execInst(nullOpt);
        priceType(nullOpt);
        bypassMQR(nullOpt);
        hedgeOnly(nullOpt);
        benchmarkPrice(nullOpt);
        benchMarkPriceType(nullOpt);
        transactDetails(nullOpt);
 
        resetVariableFields();
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef className() noexcept
    {
        return constructStrRef("NewOrderCrossRequest");
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef fixType() noexcept
    {
        return constructStrRef("s");
    }

    ONIXS_ICEBOE_NODISCARD
    std::string toString() const;

    ONIXS_ICEBOE_NODISCARD
    const void* tail() const noexcept
    {
        return
            legs().tail();
    }

    ONIXS_ICEBOE_NODISCARD
    EncodedLength calculateBinarySize() const noexcept
    {
        return
            SbeMessage::calculateBinarySize(tail());
    }
 
private:
    void checkLength(
        EncodedLength length, SchemaVersion version) const
    {
       const EncodedLength minimalRequiredLength =
           minimalBlockLength(version) +
           MessageHeader::Size +
           getMinimalVariableFieldsSize(version);
 
       checkBinaryLength(
           *this, length, minimalRequiredLength);
    }

    void checkVarLenFields() const
    {
        groups().
            checkTail<Sides>().
            checkTail<Legs>();
    }
 
    void checkCompatibility() const
    {
        assert(TemplateId == templateId());
 
        checkSchema<Schema>(schemaId(), version());
        checkLength(bufferSize(), version());
        checkVarLenFields();
    }

    struct SidesAccess
    {
        Sides operator()(const NewOrderCrossRequest& obj) const noexcept
        {
            return obj.
                groups().
                    head<Sides>();
        }
    };

    void sides(NullOpt) noexcept
    {
        resetGroup<Sides>(SidesAccess(), *this);
    }

    struct LegsAccess
    {
        Legs operator()(const NewOrderCrossRequest& obj) const noexcept
        {
            return obj.
                groups().
                    tail<Sides>().
                    head<Legs>();
        }
    };

    void legs(NullOpt) noexcept
    {
        resetGroup<Legs>(LegsAccess(), *this);
    }
};

struct
OrderMassCancelRequest
: SbeMessage
{
    typedef SchemaTraits Schema;

    typedef OrderMassCancelRequest ThisType;

    enum { TemplateId = 9 };

    OrderMassCancelRequest() = default;

    OrderMassCancelRequest(void* data, EncodedLength length, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        reset();
    }

    OrderMassCancelRequest(void* data, EncodedLength length, NoFieldsInit, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        resetVariableFields();
    }

    OrderMassCancelRequest(void* data, EncodedLength length, NoInit)
      : SbeMessage(data, length)
    {
        checkCompatibility();
    }

    explicit
    OrderMassCancelRequest(const SbeMessage& message)
      : SbeMessage(message)
    {
        assert(message.valid());
 
        checkCompatibility();
    }

    OrderMassCancelRequest(void* data, EncodedLength length, NoInit, NoCheck) noexcept
      : SbeMessage(data, length, NoCheck())
    {
        assert(schemaId() == Schema::Id);
        assert(version() >= Schema::MinimalVersion);
        assert(TemplateId == templateId());
    }

    ONIXS_ICEBOE_NODISCARD
    auto originatorUserId() const noexcept
    {
        constexpr BlockLength offset = 0;
        constexpr BlockLength length = 20;
 
        return fixedStr<length>(offset);
    }

    ThisType& originatorUserId(StrRef value) noexcept
    {
        constexpr BlockLength offset = 0;
        constexpr BlockLength length = 20;
 
        setFixedStr<length>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto ordType() const noexcept
    {
        constexpr BlockLength offset = 20;
 
        return enumeration<OrderTypeEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& ordType(OrderTypeEnum value) noexcept
    {
        constexpr BlockLength offset = 20;
 
        setEnumeration<OrderTypeEnum>(offset, value);
        return *this;
    }
 
    ThisType& ordType(NullOpt) noexcept
    {
        constexpr BlockLength offset = 20;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto side() const noexcept
    {
        constexpr BlockLength offset = 21;
 
        return enumeration<SideEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& side(SideEnum value) noexcept
    {
        constexpr BlockLength offset = 21;
 
        setEnumeration<SideEnum>(offset, value);
        return *this;
    }
 
    ThisType& side(NullOpt) noexcept
    {
        constexpr BlockLength offset = 21;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto symbol() const noexcept
    {
        constexpr BlockLength offset = 22;
 
        return ordinary<NullInt32NULL>(offset, optional);
    }

    ThisType& symbol(Int32NULL value) noexcept
    {
        constexpr BlockLength offset = 22;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& symbol(NullOpt) noexcept
    {
        constexpr BlockLength offset = 22;
 
        setOrdinary(offset, NullInt32NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto clOrdId() const noexcept
    {
        constexpr BlockLength offset = 26;
 
        return ordinary<Int64>(offset);
    }

    ThisType& clOrdId(Int64 value) noexcept
    {
        constexpr BlockLength offset = 26;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto marketTypeId() const noexcept
    {
        constexpr BlockLength offset = 34;
 
        return ordinary<NullInt32NULL>(offset, optional);
    }

    ThisType& marketTypeId(Int32NULL value) noexcept
    {
        constexpr BlockLength offset = 34;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& marketTypeId(NullOpt) noexcept
    {
        constexpr BlockLength offset = 34;
 
        setOrdinary(offset, NullInt32NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto price() const noexcept
    {
        constexpr BlockLength offset = 38;
 
        return ordinary<NullDecimal9>(offset, optional);
    }

    ThisType& price(Decimal9 value) noexcept
    {
        constexpr BlockLength offset = 38;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& price(NullOpt) noexcept
    {
        constexpr BlockLength offset = 38;
 
        setOrdinary(offset, NullDecimal9());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto massCancelRequestType() const noexcept
    {
        constexpr BlockLength offset = 46;
 
        return enumeration<MassCancelRequestTypeEnum>(offset);
    }

    ThisType& massCancelRequestType(MassCancelRequestTypeEnum value) noexcept
    {
        constexpr BlockLength offset = 46;
 
        setEnumeration<MassCancelRequestTypeEnum>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto timeInForce() const noexcept
    {
        constexpr BlockLength offset = 47;
 
        return enumeration<TimeInForceEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& timeInForce(TimeInForceEnum value) noexcept
    {
        constexpr BlockLength offset = 47;
 
        setEnumeration<TimeInForceEnum>(offset, value);
        return *this;
    }
 
    ThisType& timeInForce(NullOpt) noexcept
    {
        constexpr BlockLength offset = 47;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto onBehalfOfSubId() const noexcept
    {
        constexpr BlockLength offset = 48;
        constexpr BlockLength length = 41;
 
        return fixedStr<length>(offset, optional);
    }

    ThisType& onBehalfOfSubId(StrRef value) noexcept
    {
        constexpr BlockLength offset = 48;
        constexpr BlockLength length = 41;
 
        setFixedStr<length>(offset, value);
        return *this;
    }
 
    ThisType& onBehalfOfSubId(NullOpt) noexcept
    {
        constexpr BlockLength offset = 48;
        constexpr BlockLength length = 41;
 
        setFixedStr<length>(offset, StrRef());
        return *this;
    }

    constexpr
    static BlockLength minimalBlockLength(ONIXS_ICEBOE_UNUSED SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            89;
    }

    constexpr
    static BlockLength blockLength(SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            minimalBlockLength(version);
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static MessageSize getMinimalVariableFieldsSize(ONIXS_ICEBOE_UNUSED SchemaVersion version)
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            0;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static UInt64 getMaxMessageSize(UInt8) noexcept
    {
        return
            static_cast<UInt64>(MessageHeaderBuilder::Size) +
            blockLength(Schema::Version);
    }

    ThisType& resetVariableFields() noexcept
    {
        return *this;
    }

    ThisType& reset() noexcept
    {
        ordType(nullOpt);
        side(nullOpt);
        symbol(nullOpt);
        marketTypeId(nullOpt);
        price(nullOpt);
        timeInForce(nullOpt);
        onBehalfOfSubId(nullOpt);
 
        resetVariableFields();
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef className() noexcept
    {
        return constructStrRef("OrderMassCancelRequest");
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef fixType() noexcept
    {
        return constructStrRef("q");
    }

    ONIXS_ICEBOE_NODISCARD
    std::string toString() const;

    ONIXS_ICEBOE_NODISCARD
    const void* tail() const noexcept
    {
        return
            toOpaquePtr(
                advanceByBytes(
                    binary(),
                    static_cast<ptrdiff_t>(SbeMessage::blockLength()) +
                        MessageHeader::Size));
    }

    ONIXS_ICEBOE_NODISCARD
    EncodedLength calculateBinarySize() const noexcept
    {
        return
            SbeMessage::calculateBinarySize(tail());
    }
 
private:
    void checkLength(
        EncodedLength length, SchemaVersion version) const
    {
       const EncodedLength minimalRequiredLength =
           minimalBlockLength(version) +
           MessageHeader::Size +
           getMinimalVariableFieldsSize(version);
 
       checkBinaryLength(
           *this, length, minimalRequiredLength);
    }
 
    void checkCompatibility() const
    {
        assert(TemplateId == templateId());
 
        checkSchema<Schema>(schemaId(), version());
        checkLength(bufferSize(), version());
    }
};

struct
MassQuoteRequest
: SbeMessage
{
    typedef SchemaTraits Schema;

    typedef MassQuoteRequest ThisType;

    enum { TemplateId = 10 };

    struct
    QuoteSetsEntry : SbeGroupEntry
    <
        GroupSizeEncoding::BlockLength
    >
    {
        typedef
        SbeGroupEntry
        <
            GroupSizeEncoding::BlockLength
        >
        Base;

        typedef QuoteSetsEntry ThisType;

        QuoteSetsEntry(void* data, EncodedLength length, SchemaVersion version)
          : Base(data, numericCast<Base::BlockLength>(length), version)
        {
            assert(version >= Schema::MinimalVersion);
            assert(length >= minimalBlockLength(version));
        }

        ThisType& resetVariableFields() noexcept
        {
            return *this;
        }

        ThisType& reset() noexcept
        {
            resetVariableFields();
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto quoteSetId() const noexcept
        {
            constexpr BlockLength offset = 0;
 
            return ordinary<Int32>(offset);
        }

        ThisType& quoteSetId(Int32 value) noexcept
        {
            constexpr BlockLength offset = 0;
 
            setOrdinary(offset, value);
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto underlyingSymbol() const noexcept
        {
            constexpr BlockLength offset = 4;
 
            return ordinary<Int32>(offset);
        }

        ThisType& underlyingSymbol(Int32 value) noexcept
        {
            constexpr BlockLength offset = 4;
 
            setOrdinary(offset, value);
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto quoteEntryId() const noexcept
        {
            constexpr BlockLength offset = 8;
 
            return ordinary<Int32>(offset);
        }

        ThisType& quoteEntryId(Int32 value) noexcept
        {
            constexpr BlockLength offset = 8;
 
            setOrdinary(offset, value);
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto symbol() const noexcept
        {
            constexpr BlockLength offset = 12;
 
            return ordinary<Int32>(offset);
        }

        ThisType& symbol(Int32 value) noexcept
        {
            constexpr BlockLength offset = 12;
 
            setOrdinary(offset, value);
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto bidPx() const noexcept
        {
            constexpr BlockLength offset = 16;
 
            return ordinary<Decimal9>(offset);
        }

        ThisType& bidPx(Decimal9 value) noexcept
        {
            constexpr BlockLength offset = 16;
 
            setOrdinary(offset, value);
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto offerPx() const noexcept
        {
            constexpr BlockLength offset = 24;
 
            return ordinary<Decimal9>(offset);
        }

        ThisType& offerPx(Decimal9 value) noexcept
        {
            constexpr BlockLength offset = 24;
 
            setOrdinary(offset, value);
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto bidSz() const noexcept
        {
            constexpr BlockLength offset = 32;
 
            return ordinary<Decimal9>(offset);
        }

        ThisType& bidSz(Decimal9 value) noexcept
        {
            constexpr BlockLength offset = 32;
 
            setOrdinary(offset, value);
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto offerSz() const noexcept
        {
            constexpr BlockLength offset = 40;
 
            return ordinary<Decimal9>(offset);
        }

        ThisType& offerSz(Decimal9 value) noexcept
        {
            constexpr BlockLength offset = 40;
 
            setOrdinary(offset, value);
            return *this;
        }

        constexpr
        static BlockLength blockLength(SchemaVersion version) noexcept
        {
            return
                ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
                minimalBlockLength(version);
        }

        constexpr
        static BlockLength minimalBlockLength(ONIXS_ICEBOE_UNUSED SchemaVersion version) noexcept
        {
            return
                ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
                48;
        }

        ONIXS_ICEBOE_NODISCARD
        constexpr
        static StrRef className() noexcept
        {
            return constructStrRef("MassQuoteRequest.QuoteSetsEntry");
        }
    };

    typedef
    SbeGroup<QuoteSetsEntry, GroupSizeEncoding, MessageSize>
    QuoteSets;

    MassQuoteRequest() = default;

    MassQuoteRequest(void* data, EncodedLength length, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        reset();
    }

    MassQuoteRequest(void* data, EncodedLength length, NoFieldsInit, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        resetVariableFields();
    }

    MassQuoteRequest(void* data, EncodedLength length, NoInit)
      : SbeMessage(data, length)
    {
        checkCompatibility();
    }

    explicit
    MassQuoteRequest(const SbeMessage& message)
      : SbeMessage(message)
    {
        assert(message.valid());
 
        checkCompatibility();
    }

    MassQuoteRequest(void* data, EncodedLength length, NoInit, NoCheck) noexcept
      : SbeMessage(data, length, NoCheck())
    {
        assert(schemaId() == Schema::Id);
        assert(version() >= Schema::MinimalVersion);
        assert(TemplateId == templateId());
    }

    ONIXS_ICEBOE_NODISCARD
    auto quoteId() const noexcept
    {
        constexpr BlockLength offset = 0;
 
        return ordinary<Int64>(offset);
    }

    ThisType& quoteId(Int64 value) noexcept
    {
        constexpr BlockLength offset = 0;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto riskProtectionReset() const noexcept
    {
        constexpr BlockLength offset = 8;
 
        return enumeration<BooleanEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& riskProtectionReset(BooleanEnum value) noexcept
    {
        constexpr BlockLength offset = 8;
 
        setEnumeration<BooleanEnum>(offset, value);
        return *this;
    }
 
    ThisType& riskProtectionReset(NullOpt) noexcept
    {
        constexpr BlockLength offset = 8;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto selfMatchPreventionId() const noexcept
    {
        constexpr BlockLength offset = 9;
 
        return ordinary<NullInt64NULL>(offset, optional);
    }

    ThisType& selfMatchPreventionId(Int64NULL value) noexcept
    {
        constexpr BlockLength offset = 9;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& selfMatchPreventionId(NullOpt) noexcept
    {
        constexpr BlockLength offset = 9;
 
        setOrdinary(offset, NullInt64NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto selfMatchPreventionInstruction() const noexcept
    {
        constexpr BlockLength offset = 17;
 
        return enumeration<SelfMatchPreventionInstructionEnum, NullCharType>(offset, optional);
    }

    ThisType& selfMatchPreventionInstruction(SelfMatchPreventionInstructionEnum value) noexcept
    {
        constexpr BlockLength offset = 17;
 
        setEnumeration<SelfMatchPreventionInstructionEnum>(offset, value);
        return *this;
    }
 
    ThisType& selfMatchPreventionInstruction(NullOpt) noexcept
    {
        constexpr BlockLength offset = 17;
 
        setOrdinary(offset, NullCharType());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto originatorUserId() const noexcept
    {
        constexpr BlockLength offset = 18;
        constexpr BlockLength length = 20;
 
        return fixedStr<length>(offset);
    }

    ThisType& originatorUserId(StrRef value) noexcept
    {
        constexpr BlockLength offset = 18;
        constexpr BlockLength length = 20;
 
        setFixedStr<length>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto directElectronicAccess() const noexcept
    {
        constexpr BlockLength offset = 38;
 
        return enumeration<BooleanEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& directElectronicAccess(BooleanEnum value) noexcept
    {
        constexpr BlockLength offset = 38;
 
        setEnumeration<BooleanEnum>(offset, value);
        return *this;
    }
 
    ThisType& directElectronicAccess(NullOpt) noexcept
    {
        constexpr BlockLength offset = 38;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto tradingCapacity() const noexcept
    {
        constexpr BlockLength offset = 39;
 
        return enumeration<TradingCapacityEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& tradingCapacity(TradingCapacityEnum value) noexcept
    {
        constexpr BlockLength offset = 39;
 
        setEnumeration<TradingCapacityEnum>(offset, value);
        return *this;
    }
 
    ThisType& tradingCapacity(NullOpt) noexcept
    {
        constexpr BlockLength offset = 39;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto liquidityProvision() const noexcept
    {
        constexpr BlockLength offset = 40;
 
        return enumeration<BooleanEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& liquidityProvision(BooleanEnum value) noexcept
    {
        constexpr BlockLength offset = 40;
 
        setEnumeration<BooleanEnum>(offset, value);
        return *this;
    }
 
    ThisType& liquidityProvision(NullOpt) noexcept
    {
        constexpr BlockLength offset = 40;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto commodityDerivIndicator() const noexcept
    {
        constexpr BlockLength offset = 41;
 
        return enumeration<BooleanEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& commodityDerivIndicator(BooleanEnum value) noexcept
    {
        constexpr BlockLength offset = 41;
 
        setEnumeration<BooleanEnum>(offset, value);
        return *this;
    }
 
    ThisType& commodityDerivIndicator(NullOpt) noexcept
    {
        constexpr BlockLength offset = 41;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto investmentDecision() const noexcept
    {
        constexpr BlockLength offset = 42;
 
        return ordinary<NullInt64NULL>(offset, optional);
    }

    ThisType& investmentDecision(Int64NULL value) noexcept
    {
        constexpr BlockLength offset = 42;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& investmentDecision(NullOpt) noexcept
    {
        constexpr BlockLength offset = 42;
 
        setOrdinary(offset, NullInt64NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto executionDecision() const noexcept
    {
        constexpr BlockLength offset = 50;
 
        return ordinary<NullInt64NULL>(offset, optional);
    }

    ThisType& executionDecision(Int64NULL value) noexcept
    {
        constexpr BlockLength offset = 50;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& executionDecision(NullOpt) noexcept
    {
        constexpr BlockLength offset = 50;
 
        setOrdinary(offset, NullInt64NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto clientIdCode() const noexcept
    {
        constexpr BlockLength offset = 58;
 
        return ordinary<NullInt64NULL>(offset, optional);
    }

    ThisType& clientIdCode(Int64NULL value) noexcept
    {
        constexpr BlockLength offset = 58;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& clientIdCode(NullOpt) noexcept
    {
        constexpr BlockLength offset = 58;
 
        setOrdinary(offset, NullInt64NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto mifidId() const noexcept
    {
        constexpr BlockLength offset = 66;
 
        return ordinary<NullInt64NULL>(offset, optional);
    }

    ThisType& mifidId(Int64NULL value) noexcept
    {
        constexpr BlockLength offset = 66;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& mifidId(NullOpt) noexcept
    {
        constexpr BlockLength offset = 66;
 
        setOrdinary(offset, NullInt64NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    QuoteSets quoteSets() const noexcept
    {
        return getGroup<QuoteSets>(QuoteSetsAccess(), *this);
    }

    ONIXS_ICEBOE_NODISCARD
    QuoteSets quoteSets() noexcept
    {
        return getGroup<QuoteSets>(QuoteSetsAccess(), *this);
    }

    QuoteSets quoteSets(QuoteSets::Size length)
    {
        return constructGroup<QuoteSets>(
            QuoteSetsAccess(),
            length,
            *this);
    }

    QuoteSets quoteSets(QuoteSets::Size length, NoFieldsInit)
    {
        return setupGroup<QuoteSets>(
            QuoteSetsAccess(),
            length,
            *this);
    }

    constexpr
    static BlockLength minimalBlockLength(ONIXS_ICEBOE_UNUSED SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            74;
    }

    constexpr
    static BlockLength blockLength(SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            minimalBlockLength(version);
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static MessageSize getMinimalVariableFieldsSize(ONIXS_ICEBOE_UNUSED SchemaVersion version)
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            static_cast<MessageSize>(QuoteSets::EmptySize);
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static UInt64 getMaxMessageSize(UInt8 maxGroupItems = 255) noexcept
    {
        return
            static_cast<UInt64>(MessageHeaderBuilder::Size) +
            blockLength(Schema::Version) +
            (GroupSizeEncoding::Size + QuoteSetsEntry::blockLength(Schema::Version) * static_cast<UInt64>(maxGroupItems));
    }

    ThisType& resetVariableFields() noexcept
    {
        quoteSets(nullOpt);
        return *this;
    }

    ThisType& reset() noexcept
    {
        riskProtectionReset(nullOpt);
        selfMatchPreventionId(nullOpt);
        selfMatchPreventionInstruction(nullOpt);
        directElectronicAccess(nullOpt);
        tradingCapacity(nullOpt);
        liquidityProvision(nullOpt);
        commodityDerivIndicator(nullOpt);
        investmentDecision(nullOpt);
        executionDecision(nullOpt);
        clientIdCode(nullOpt);
        mifidId(nullOpt);
 
        resetVariableFields();
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef className() noexcept
    {
        return constructStrRef("MassQuoteRequest");
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef fixType() noexcept
    {
        return constructStrRef("i");
    }

    ONIXS_ICEBOE_NODISCARD
    std::string toString() const;

    ONIXS_ICEBOE_NODISCARD
    const void* tail() const noexcept
    {
        return
            quoteSets().tail();
    }

    ONIXS_ICEBOE_NODISCARD
    EncodedLength calculateBinarySize() const noexcept
    {
        return
            SbeMessage::calculateBinarySize(tail());
    }
 
private:
    void checkLength(
        EncodedLength length, SchemaVersion version) const
    {
       const EncodedLength minimalRequiredLength =
           minimalBlockLength(version) +
           MessageHeader::Size +
           getMinimalVariableFieldsSize(version);
 
       checkBinaryLength(
           *this, length, minimalRequiredLength);
    }

    void checkVarLenFields() const
    {
        groups().
            checkTail<QuoteSets>();
    }
 
    void checkCompatibility() const
    {
        assert(TemplateId == templateId());
 
        checkSchema<Schema>(schemaId(), version());
        checkLength(bufferSize(), version());
        checkVarLenFields();
    }

    struct QuoteSetsAccess
    {
        QuoteSets operator()(const MassQuoteRequest& obj) const noexcept
        {
            return obj.
                groups().
                    head<QuoteSets>();
        }
    };

    void quoteSets(NullOpt) noexcept
    {
        resetGroup<QuoteSets>(QuoteSetsAccess(), *this);
    }
};

struct
QuoteCancelRequest
: SbeMessage
{
    typedef SchemaTraits Schema;

    typedef QuoteCancelRequest ThisType;

    enum { TemplateId = 11 };

    struct
    QuoteEntry : SbeGroupEntry
    <
        GroupSizeEncoding::BlockLength
    >
    {
        typedef
        SbeGroupEntry
        <
            GroupSizeEncoding::BlockLength
        >
        Base;

        typedef QuoteEntry ThisType;

        QuoteEntry(void* data, EncodedLength length, SchemaVersion version)
          : Base(data, numericCast<Base::BlockLength>(length), version)
        {
            assert(version >= Schema::MinimalVersion);
            assert(length >= minimalBlockLength(version));
        }

        ThisType& resetVariableFields() noexcept
        {
            return *this;
        }

        ThisType& reset() noexcept
        {
            underlyingSymbol(nullOpt);
            underlyingSecurityId(nullOpt);
            underlyingProduct(nullOpt);
 
            resetVariableFields();
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto underlyingSymbol() const noexcept
        {
            constexpr BlockLength offset = 0;
 
            return ordinary<NullInt32NULL>(offset, optional);
        }

        ThisType& underlyingSymbol(Int32NULL value) noexcept
        {
            constexpr BlockLength offset = 0;
 
            setOrdinary(offset, value);
            return *this;
        }
 
        ThisType& underlyingSymbol(NullOpt) noexcept
        {
            constexpr BlockLength offset = 0;
 
            setOrdinary(offset, NullInt32NULL());
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto underlyingSecurityId() const noexcept
        {
            constexpr BlockLength offset = 4;
 
            return ordinary<NullInt32NULL>(offset, optional);
        }

        ThisType& underlyingSecurityId(Int32NULL value) noexcept
        {
            constexpr BlockLength offset = 4;
 
            setOrdinary(offset, value);
            return *this;
        }
 
        ThisType& underlyingSecurityId(NullOpt) noexcept
        {
            constexpr BlockLength offset = 4;
 
            setOrdinary(offset, NullInt32NULL());
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto underlyingProduct() const noexcept
        {
            constexpr BlockLength offset = 8;
 
            return ordinary<NullInt32NULL>(offset, optional);
        }

        ThisType& underlyingProduct(Int32NULL value) noexcept
        {
            constexpr BlockLength offset = 8;
 
            setOrdinary(offset, value);
            return *this;
        }
 
        ThisType& underlyingProduct(NullOpt) noexcept
        {
            constexpr BlockLength offset = 8;
 
            setOrdinary(offset, NullInt32NULL());
            return *this;
        }

        constexpr
        static BlockLength blockLength(SchemaVersion version) noexcept
        {
            return
                ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
                minimalBlockLength(version);
        }

        constexpr
        static BlockLength minimalBlockLength(ONIXS_ICEBOE_UNUSED SchemaVersion version) noexcept
        {
            return
                ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
                12;
        }

        ONIXS_ICEBOE_NODISCARD
        constexpr
        static StrRef className() noexcept
        {
            return constructStrRef("QuoteCancelRequest.QuoteEntry");
        }
    };

    typedef
    SbeGroup<QuoteEntry, GroupSizeEncoding, MessageSize>
    QuoteEntries;

    QuoteCancelRequest() = default;

    QuoteCancelRequest(void* data, EncodedLength length, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        reset();
    }

    QuoteCancelRequest(void* data, EncodedLength length, NoFieldsInit, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        resetVariableFields();
    }

    QuoteCancelRequest(void* data, EncodedLength length, NoInit)
      : SbeMessage(data, length)
    {
        checkCompatibility();
    }

    explicit
    QuoteCancelRequest(const SbeMessage& message)
      : SbeMessage(message)
    {
        assert(message.valid());
 
        checkCompatibility();
    }

    QuoteCancelRequest(void* data, EncodedLength length, NoInit, NoCheck) noexcept
      : SbeMessage(data, length, NoCheck())
    {
        assert(schemaId() == Schema::Id);
        assert(version() >= Schema::MinimalVersion);
        assert(TemplateId == templateId());
    }

    ONIXS_ICEBOE_NODISCARD
    auto quoteId() const noexcept
    {
        constexpr BlockLength offset = 0;
 
        return ordinary<Int64>(offset);
    }

    ThisType& quoteId(Int64 value) noexcept
    {
        constexpr BlockLength offset = 0;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto quoteCancelType() const noexcept
    {
        constexpr BlockLength offset = 8;
 
        return enumeration<QuoteCancelTypeEnum>(offset);
    }

    ThisType& quoteCancelType(QuoteCancelTypeEnum value) noexcept
    {
        constexpr BlockLength offset = 8;
 
        setEnumeration<QuoteCancelTypeEnum>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto originatorUserId() const noexcept
    {
        constexpr BlockLength offset = 9;
        constexpr BlockLength length = 20;
 
        return fixedStr<length>(offset);
    }

    ThisType& originatorUserId(StrRef value) noexcept
    {
        constexpr BlockLength offset = 9;
        constexpr BlockLength length = 20;
 
        setFixedStr<length>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    QuoteEntries quoteEntries() const noexcept
    {
        return getGroup<QuoteEntries>(
            QuoteEntriesAccess(),
            *this);
    }

    ONIXS_ICEBOE_NODISCARD
    QuoteEntries quoteEntries() noexcept
    {
        return getGroup<QuoteEntries>(
            QuoteEntriesAccess(),
            *this);
    }

    QuoteEntries quoteEntries(QuoteEntries::Size length)
    {
        return constructGroup<QuoteEntries>(
            QuoteEntriesAccess(),
            length,
            *this);
    }

    QuoteEntries quoteEntries(QuoteEntries::Size length, NoFieldsInit)
    {
        return setupGroup<QuoteEntries>(
            QuoteEntriesAccess(),
            length,
            *this);
    }

    constexpr
    static BlockLength minimalBlockLength(ONIXS_ICEBOE_UNUSED SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            29;
    }

    constexpr
    static BlockLength blockLength(SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            minimalBlockLength(version);
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static MessageSize getMinimalVariableFieldsSize(ONIXS_ICEBOE_UNUSED SchemaVersion version)
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            static_cast<MessageSize>(QuoteEntries::EmptySize);
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static UInt64 getMaxMessageSize(UInt8 maxGroupItems = 255) noexcept
    {
        return
            static_cast<UInt64>(MessageHeaderBuilder::Size) +
            blockLength(Schema::Version) +
            (GroupSizeEncoding::Size + QuoteEntry::blockLength(Schema::Version) * static_cast<UInt64>(maxGroupItems));
    }

    ThisType& resetVariableFields() noexcept
    {
        quoteEntries(nullOpt);
        return *this;
    }

    ThisType& reset() noexcept
    {
        resetVariableFields();
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef className() noexcept
    {
        return constructStrRef("QuoteCancelRequest");
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef fixType() noexcept
    {
        return constructStrRef("Z");
    }

    ONIXS_ICEBOE_NODISCARD
    std::string toString() const;

    ONIXS_ICEBOE_NODISCARD
    const void* tail() const noexcept
    {
        return
            quoteEntries().tail();
    }

    ONIXS_ICEBOE_NODISCARD
    EncodedLength calculateBinarySize() const noexcept
    {
        return
            SbeMessage::calculateBinarySize(tail());
    }
 
private:
    void checkLength(
        EncodedLength length, SchemaVersion version) const
    {
       const EncodedLength minimalRequiredLength =
           minimalBlockLength(version) +
           MessageHeader::Size +
           getMinimalVariableFieldsSize(version);
 
       checkBinaryLength(
           *this, length, minimalRequiredLength);
    }

    void checkVarLenFields() const
    {
        groups().
            checkTail<QuoteEntries>();
    }
 
    void checkCompatibility() const
    {
        assert(TemplateId == templateId());
 
        checkSchema<Schema>(schemaId(), version());
        checkLength(bufferSize(), version());
        checkVarLenFields();
    }

    struct QuoteEntriesAccess
    {
        QuoteEntries operator()(const QuoteCancelRequest& obj) const noexcept
        {
            return obj.
                groups().
                    head<QuoteEntries>();
        }
    };

    void quoteEntries(NullOpt) noexcept
    {
        resetGroup<QuoteEntries>(
            QuoteEntriesAccess(),
            *this);
    }
};

struct
SecurityDefinitionRequest_CreateStrategy
: SbeMessage
{
    typedef SchemaTraits Schema;

    typedef SecurityDefinitionRequest_CreateStrategy ThisType;

    enum { TemplateId = 12 };

    struct
    LegsEntry : SbeGroupEntry
    <
        GroupSizeEncoding::BlockLength
    >
    {
        typedef
        SbeGroupEntry
        <
            GroupSizeEncoding::BlockLength
        >
        Base;

        typedef LegsEntry ThisType;

        LegsEntry(void* data, EncodedLength length, SchemaVersion version)
          : Base(data, numericCast<Base::BlockLength>(length), version)
        {
            assert(version >= Schema::MinimalVersion);
            assert(length >= minimalBlockLength(version));
        }

        ThisType& resetVariableFields() noexcept
        {
            return *this;
        }

        ThisType& reset() noexcept
        {
            legRatioQtyDenominator(nullOpt);
            legRatioQtyNumerator(nullOpt);
            legPrice(nullOpt);
            legOptionDelta(nullOpt);
 
            resetVariableFields();
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto legSymbol() const noexcept
        {
            constexpr BlockLength offset = 0;
 
            return ordinary<Int32>(offset);
        }

        ThisType& legSymbol(Int32 value) noexcept
        {
            constexpr BlockLength offset = 0;
 
            setOrdinary(offset, value);
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto legSecurityType() const noexcept
        {
            constexpr BlockLength offset = 4;
 
            return enumeration<SecurityTypeEnum>(offset);
        }

        ThisType& legSecurityType(SecurityTypeEnum value) noexcept
        {
            constexpr BlockLength offset = 4;
 
            setEnumeration<SecurityTypeEnum>(offset, value);
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto legSide() const noexcept
        {
            constexpr BlockLength offset = 5;
 
            return enumeration<SideEnum>(offset);
        }

        ThisType& legSide(SideEnum value) noexcept
        {
            constexpr BlockLength offset = 5;
 
            setEnumeration<SideEnum>(offset, value);
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto legRatioQtyDenominator() const noexcept
        {
            constexpr BlockLength offset = 6;
 
            return ordinary<NullInt16NULL>(offset, optional);
        }

        ThisType& legRatioQtyDenominator(Int16NULL value) noexcept
        {
            constexpr BlockLength offset = 6;
 
            setOrdinary(offset, value);
            return *this;
        }
 
        ThisType& legRatioQtyDenominator(NullOpt) noexcept
        {
            constexpr BlockLength offset = 6;
 
            setOrdinary(offset, NullInt16NULL());
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto legRatioQtyNumerator() const noexcept
        {
            constexpr BlockLength offset = 8;
 
            return ordinary<NullInt16NULL>(offset, optional);
        }

        ThisType& legRatioQtyNumerator(Int16NULL value) noexcept
        {
            constexpr BlockLength offset = 8;
 
            setOrdinary(offset, value);
            return *this;
        }
 
        ThisType& legRatioQtyNumerator(NullOpt) noexcept
        {
            constexpr BlockLength offset = 8;
 
            setOrdinary(offset, NullInt16NULL());
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto legPrice() const noexcept
        {
            constexpr BlockLength offset = 10;
 
            return ordinary<NullDecimal9>(offset, optional);
        }

        ThisType& legPrice(Decimal9 value) noexcept
        {
            constexpr BlockLength offset = 10;
 
            setOrdinary(offset, value);
            return *this;
        }
 
        ThisType& legPrice(NullOpt) noexcept
        {
            constexpr BlockLength offset = 10;
 
            setOrdinary(offset, NullDecimal9());
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto legOptionDelta() const noexcept
        {
            constexpr BlockLength offset = 18;
 
            return ordinary<NullInt32NULL>(offset, optional);
        }

        ThisType& legOptionDelta(Int32NULL value) noexcept
        {
            constexpr BlockLength offset = 18;
 
            setOrdinary(offset, value);
            return *this;
        }
 
        ThisType& legOptionDelta(NullOpt) noexcept
        {
            constexpr BlockLength offset = 18;
 
            setOrdinary(offset, NullInt32NULL());
            return *this;
        }

        constexpr
        static BlockLength blockLength(SchemaVersion version) noexcept
        {
            return
                ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
                minimalBlockLength(version);
        }

        constexpr
        static BlockLength minimalBlockLength(ONIXS_ICEBOE_UNUSED SchemaVersion version) noexcept
        {
            return
                ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
                22;
        }

        ONIXS_ICEBOE_NODISCARD
        constexpr
        static StrRef className() noexcept
        {
            return constructStrRef("SecurityDefinitionRequest_CreateStrategy.LegsEntry");
        }
    };

    typedef
    SbeGroup<LegsEntry, GroupSizeEncoding, MessageSize>
    Legs;

    SecurityDefinitionRequest_CreateStrategy() = default;

    SecurityDefinitionRequest_CreateStrategy(void* data, EncodedLength length, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        reset();
    }

    SecurityDefinitionRequest_CreateStrategy(void* data, EncodedLength length, NoFieldsInit, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        resetVariableFields();
    }

    SecurityDefinitionRequest_CreateStrategy(void* data, EncodedLength length, NoInit)
      : SbeMessage(data, length)
    {
        checkCompatibility();
    }

    explicit
    SecurityDefinitionRequest_CreateStrategy(const SbeMessage& message)
      : SbeMessage(message)
    {
        assert(message.valid());
 
        checkCompatibility();
    }

    SecurityDefinitionRequest_CreateStrategy(void* data, EncodedLength length, NoInit, NoCheck) noexcept
      : SbeMessage(data, length, NoCheck())
    {
        assert(schemaId() == Schema::Id);
        assert(version() >= Schema::MinimalVersion);
        assert(TemplateId == templateId());
    }

    ONIXS_ICEBOE_NODISCARD
    auto securityReqId() const noexcept
    {
        constexpr BlockLength offset = 0;
 
        return ordinary<Int32>(offset);
    }

    ThisType& securityReqId(Int32 value) noexcept
    {
        constexpr BlockLength offset = 0;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto securityRequestType() const noexcept
    {
        constexpr BlockLength offset = 4;
 
        return enumeration<SecurityRequestTypeEnum>(offset);
    }

    ThisType& securityRequestType(SecurityRequestTypeEnum value) noexcept
    {
        constexpr BlockLength offset = 4;
 
        setEnumeration<SecurityRequestTypeEnum>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto marketTypeId() const noexcept
    {
        constexpr BlockLength offset = 5;
 
        return ordinary<Int32>(offset);
    }

    ThisType& marketTypeId(Int32 value) noexcept
    {
        constexpr BlockLength offset = 5;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto securitySubType() const noexcept
    {
        constexpr BlockLength offset = 9;
 
        return ordinary<NullInt16NULL>(offset, optional);
    }

    ThisType& securitySubType(Int16NULL value) noexcept
    {
        constexpr BlockLength offset = 9;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& securitySubType(NullOpt) noexcept
    {
        constexpr BlockLength offset = 9;
 
        setOrdinary(offset, NullInt16NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto productId() const noexcept
    {
        constexpr BlockLength offset = 11;
 
        return ordinary<NullInt32NULL>(offset, optional);
    }

    ThisType& productId(Int32NULL value) noexcept
    {
        constexpr BlockLength offset = 11;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& productId(NullOpt) noexcept
    {
        constexpr BlockLength offset = 11;
 
        setOrdinary(offset, NullInt32NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto startDate() const noexcept(dateToTimestamp::Nothrow)
    {
        constexpr BlockLength offset = 15;
        return convertible<NullUTCDateOnly, dateToTimestamp>(offset, optional);
    }

    ThisType& startDate(Timestamp value) noexcept(timestampToDate::Nothrow)
    {
        constexpr BlockLength offset = 15;
 
        setOrdinary(offset, convert<timestampToDate>(value));
        return *this;
    }
 
    ThisType& startDate(NullOpt) noexcept
    {
        constexpr BlockLength offset = 15;
 
        setOrdinary(offset, NullUTCDateOnly());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto endDate() const noexcept(dateToTimestamp::Nothrow)
    {
        constexpr BlockLength offset = 17;
        return convertible<NullUTCDateOnly, dateToTimestamp>(offset, optional);
    }

    ThisType& endDate(Timestamp value) noexcept(timestampToDate::Nothrow)
    {
        constexpr BlockLength offset = 17;
 
        setOrdinary(offset, convert<timestampToDate>(value));
        return *this;
    }
 
    ThisType& endDate(NullOpt) noexcept
    {
        constexpr BlockLength offset = 17;
 
        setOrdinary(offset, NullUTCDateOnly());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto securityType() const noexcept
    {
        constexpr BlockLength offset = 19;
 
        return enumeration<SecurityTypeEnum>(offset);
    }

    ThisType& securityType(SecurityTypeEnum value) noexcept
    {
        constexpr BlockLength offset = 19;
 
        setEnumeration<SecurityTypeEnum>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    Legs legs() const noexcept
    {
        return getGroup<Legs>(LegsAccess(), *this);
    }

    ONIXS_ICEBOE_NODISCARD
    Legs legs() noexcept
    {
        return getGroup<Legs>(LegsAccess(), *this);
    }

    Legs legs(Legs::Size length)
    {
        return constructGroup<Legs>(
            LegsAccess(),
            length,
            *this);
    }

    Legs legs(Legs::Size length, NoFieldsInit)
    {
        return setupGroup<Legs>(
            LegsAccess(),
            length,
            *this);
    }

    constexpr
    static BlockLength minimalBlockLength(ONIXS_ICEBOE_UNUSED SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            20;
    }

    constexpr
    static BlockLength blockLength(SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            minimalBlockLength(version);
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static MessageSize getMinimalVariableFieldsSize(ONIXS_ICEBOE_UNUSED SchemaVersion version)
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            static_cast<MessageSize>(Legs::EmptySize);
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static UInt64 getMaxMessageSize(UInt8 maxGroupItems = 255) noexcept
    {
        return
            static_cast<UInt64>(MessageHeaderBuilder::Size) +
            blockLength(Schema::Version) +
            (GroupSizeEncoding::Size + LegsEntry::blockLength(Schema::Version) * static_cast<UInt64>(maxGroupItems));
    }

    ThisType& resetVariableFields() noexcept
    {
        legs(nullOpt);
        return *this;
    }

    ThisType& reset() noexcept
    {
        securitySubType(nullOpt);
        productId(nullOpt);
        startDate(nullOpt);
        endDate(nullOpt);
 
        resetVariableFields();
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef className() noexcept
    {
        return constructStrRef("SecurityDefinitionRequest_CreateStrategy");
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef fixType() noexcept
    {
        return constructStrRef("c");
    }

    ONIXS_ICEBOE_NODISCARD
    std::string toString() const;

    ONIXS_ICEBOE_NODISCARD
    const void* tail() const noexcept
    {
        return
            legs().tail();
    }

    ONIXS_ICEBOE_NODISCARD
    EncodedLength calculateBinarySize() const noexcept
    {
        return
            SbeMessage::calculateBinarySize(tail());
    }
 
private:
    void checkLength(
        EncodedLength length, SchemaVersion version) const
    {
       const EncodedLength minimalRequiredLength =
           minimalBlockLength(version) +
           MessageHeader::Size +
           getMinimalVariableFieldsSize(version);
 
       checkBinaryLength(
           *this, length, minimalRequiredLength);
    }

    void checkVarLenFields() const
    {
        groups().
            checkTail<Legs>();
    }
 
    void checkCompatibility() const
    {
        assert(TemplateId == templateId());
 
        checkSchema<Schema>(schemaId(), version());
        checkLength(bufferSize(), version());
        checkVarLenFields();
    }

    struct LegsAccess
    {
        Legs operator()(const SecurityDefinitionRequest_CreateStrategy& obj) const noexcept
        {
            return obj.
                groups().
                    head<Legs>();
        }
    };

    void legs(NullOpt) noexcept
    {
        resetGroup<Legs>(LegsAccess(), *this);
    }
};

struct
SecurityDefinitionRequest_CreateFlex
: SbeMessage
{
    typedef SchemaTraits Schema;

    typedef SecurityDefinitionRequest_CreateFlex ThisType;

    enum { TemplateId = 14 };

    SecurityDefinitionRequest_CreateFlex() = default;

    SecurityDefinitionRequest_CreateFlex(void* data, EncodedLength length, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        reset();
    }

    SecurityDefinitionRequest_CreateFlex(void* data, EncodedLength length, NoFieldsInit, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        resetVariableFields();
    }

    SecurityDefinitionRequest_CreateFlex(void* data, EncodedLength length, NoInit)
      : SbeMessage(data, length)
    {
        checkCompatibility();
    }

    explicit
    SecurityDefinitionRequest_CreateFlex(const SbeMessage& message)
      : SbeMessage(message)
    {
        assert(message.valid());
 
        checkCompatibility();
    }

    SecurityDefinitionRequest_CreateFlex(void* data, EncodedLength length, NoInit, NoCheck) noexcept
      : SbeMessage(data, length, NoCheck())
    {
        assert(schemaId() == Schema::Id);
        assert(version() >= Schema::MinimalVersion);
        assert(TemplateId == templateId());
    }

    ONIXS_ICEBOE_NODISCARD
    auto securityReqId() const noexcept
    {
        constexpr BlockLength offset = 0;
 
        return ordinary<Int32>(offset);
    }

    ThisType& securityReqId(Int32 value) noexcept
    {
        constexpr BlockLength offset = 0;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto securityRequestType() const noexcept
    {
        constexpr BlockLength offset = 4;
 
        return enumeration<SecurityRequestTypeEnum>(offset);
    }

    ThisType& securityRequestType(SecurityRequestTypeEnum value) noexcept
    {
        constexpr BlockLength offset = 4;
 
        setEnumeration<SecurityRequestTypeEnum>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto marketTypeId() const noexcept
    {
        constexpr BlockLength offset = 5;
 
        return ordinary<Int32>(offset);
    }

    ThisType& marketTypeId(Int32 value) noexcept
    {
        constexpr BlockLength offset = 5;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto securityType() const noexcept
    {
        constexpr BlockLength offset = 9;
 
        return enumeration<SecurityTypeEnum>(offset);
    }

    ThisType& securityType(SecurityTypeEnum value) noexcept
    {
        constexpr BlockLength offset = 9;
 
        setEnumeration<SecurityTypeEnum>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto maturityDate() const noexcept(dateToTimestamp::Nothrow)
    {
        constexpr BlockLength offset = 10;
        return convertible<NullUTCDateOnly, dateToTimestamp>(offset, optional);
    }

    ThisType& maturityDate(Timestamp value) noexcept(timestampToDate::Nothrow)
    {
        constexpr BlockLength offset = 10;
 
        setOrdinary(offset, convert<timestampToDate>(value));
        return *this;
    }
 
    ThisType& maturityDate(NullOpt) noexcept
    {
        constexpr BlockLength offset = 10;
 
        setOrdinary(offset, NullUTCDateOnly());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto productId() const noexcept
    {
        constexpr BlockLength offset = 12;
 
        return ordinary<NullInt32NULL>(offset, optional);
    }

    ThisType& productId(Int32NULL value) noexcept
    {
        constexpr BlockLength offset = 12;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& productId(NullOpt) noexcept
    {
        constexpr BlockLength offset = 12;
 
        setOrdinary(offset, NullInt32NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto symbol() const noexcept
    {
        constexpr BlockLength offset = 16;
 
        return ordinary<NullInt32NULL>(offset, optional);
    }

    ThisType& symbol(Int32NULL value) noexcept
    {
        constexpr BlockLength offset = 16;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& symbol(NullOpt) noexcept
    {
        constexpr BlockLength offset = 16;
 
        setOrdinary(offset, NullInt32NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto strikePrice() const noexcept
    {
        constexpr BlockLength offset = 20;
 
        return ordinary<NullDecimal9>(offset, optional);
    }

    ThisType& strikePrice(Decimal9 value) noexcept
    {
        constexpr BlockLength offset = 20;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& strikePrice(NullOpt) noexcept
    {
        constexpr BlockLength offset = 20;
 
        setOrdinary(offset, NullDecimal9());
        return *this;
    }

    constexpr
    static BlockLength minimalBlockLength(ONIXS_ICEBOE_UNUSED SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            28;
    }

    constexpr
    static BlockLength blockLength(SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            minimalBlockLength(version);
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static MessageSize getMinimalVariableFieldsSize(ONIXS_ICEBOE_UNUSED SchemaVersion version)
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            0;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static UInt64 getMaxMessageSize(UInt8) noexcept
    {
        return
            static_cast<UInt64>(MessageHeaderBuilder::Size) +
            blockLength(Schema::Version);
    }

    ThisType& resetVariableFields() noexcept
    {
        return *this;
    }

    ThisType& reset() noexcept
    {
        maturityDate(nullOpt);
        productId(nullOpt);
        symbol(nullOpt);
        strikePrice(nullOpt);
 
        resetVariableFields();
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef className() noexcept
    {
        return constructStrRef("SecurityDefinitionRequest_CreateFlex");
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef fixType() noexcept
    {
        return constructStrRef("c");
    }

    ONIXS_ICEBOE_NODISCARD
    std::string toString() const;

    ONIXS_ICEBOE_NODISCARD
    const void* tail() const noexcept
    {
        return
            toOpaquePtr(
                advanceByBytes(
                    binary(),
                    static_cast<ptrdiff_t>(SbeMessage::blockLength()) +
                        MessageHeader::Size));
    }

    ONIXS_ICEBOE_NODISCARD
    EncodedLength calculateBinarySize() const noexcept
    {
        return
            SbeMessage::calculateBinarySize(tail());
    }
 
private:
    void checkLength(
        EncodedLength length, SchemaVersion version) const
    {
       const EncodedLength minimalRequiredLength =
           minimalBlockLength(version) +
           MessageHeader::Size +
           getMinimalVariableFieldsSize(version);
 
       checkBinaryLength(
           *this, length, minimalRequiredLength);
    }
 
    void checkCompatibility() const
    {
        assert(TemplateId == templateId());
 
        checkSchema<Schema>(schemaId(), version());
        checkLength(bufferSize(), version());
    }
};

struct
ExecutionReport_New
: SbeMessage
{
    typedef SchemaTraits Schema;

    typedef ExecutionReport_New ThisType;

    enum { TemplateId = 104 };

    ExecutionReport_New() = default;

    ExecutionReport_New(void* data, EncodedLength length, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        reset();
    }

    ExecutionReport_New(void* data, EncodedLength length, NoFieldsInit, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        resetVariableFields();
    }

    ExecutionReport_New(void* data, EncodedLength length, NoInit)
      : SbeMessage(data, length)
    {
        checkCompatibility();
    }

    explicit
    ExecutionReport_New(const SbeMessage& message)
      : SbeMessage(message)
    {
        assert(message.valid());
 
        checkCompatibility();
    }

    ExecutionReport_New(void* data, EncodedLength length, NoInit, NoCheck) noexcept
      : SbeMessage(data, length, NoCheck())
    {
        assert(schemaId() == Schema::Id);
        assert(version() >= Schema::MinimalVersion);
        assert(TemplateId == templateId());
    }

    ONIXS_ICEBOE_NODISCARD
    auto originatorUserId() const noexcept
    {
        constexpr BlockLength offset = 0;
        constexpr BlockLength length = 20;
 
        return fixedStr<length>(offset);
    }

    ThisType& originatorUserId(StrRef value) noexcept
    {
        constexpr BlockLength offset = 0;
        constexpr BlockLength length = 20;
 
        setFixedStr<length>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto execId() const noexcept
    {
        constexpr BlockLength offset = 20;
 
        return ordinary<OrderExecID>(offset);
    }

    ThisType& execId(ChooseValueKind<OrderExecID> value) noexcept
    {
        constexpr BlockLength offset = 20;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto clOrdId() const noexcept
    {
        constexpr BlockLength offset = 40;
 
        return ordinary<Int64>(offset);
    }

    ThisType& clOrdId(Int64 value) noexcept
    {
        constexpr BlockLength offset = 40;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto symbol() const noexcept
    {
        constexpr BlockLength offset = 48;
 
        return ordinary<Int32>(offset);
    }

    ThisType& symbol(Int32 value) noexcept
    {
        constexpr BlockLength offset = 48;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto ordType() const noexcept
    {
        constexpr BlockLength offset = 52;
 
        return enumeration<OrderTypeEnum>(offset);
    }

    ThisType& ordType(OrderTypeEnum value) noexcept
    {
        constexpr BlockLength offset = 52;
 
        setEnumeration<OrderTypeEnum>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto side() const noexcept
    {
        constexpr BlockLength offset = 53;
 
        return enumeration<SideEnum>(offset);
    }

    ThisType& side(SideEnum value) noexcept
    {
        constexpr BlockLength offset = 53;
 
        setEnumeration<SideEnum>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto origOrderId() const noexcept
    {
        constexpr BlockLength offset = 54;
 
        return ordinary<NullOriginalOrderID>(offset, optional);
    }

    ThisType& origOrderId(OriginalOrderID value) noexcept
    {
        constexpr BlockLength offset = 54;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& origOrderId(NullOpt) noexcept
    {
        constexpr BlockLength offset = 54;
 
        setOrdinary(offset, NullOriginalOrderID());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto leavesQty() const noexcept
    {
        constexpr BlockLength offset = 70;
 
        return ordinary<Decimal9>(offset);
    }

    ThisType& leavesQty(Decimal9 value) noexcept
    {
        constexpr BlockLength offset = 70;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto price() const noexcept
    {
        constexpr BlockLength offset = 78;
 
        return ordinary<NullDecimal9>(offset, optional);
    }

    ThisType& price(Decimal9 value) noexcept
    {
        constexpr BlockLength offset = 78;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& price(NullOpt) noexcept
    {
        constexpr BlockLength offset = 78;
 
        setOrdinary(offset, NullDecimal9());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto meAcceptanceTime() const noexcept(ticksToTimestamp::Nothrow)
    {
        constexpr BlockLength offset = 86;
        return convertible<ticksToTimestamp>(offset);
    }

    ThisType& meAcceptanceTime(Timestamp value) noexcept(timestampToTicks::Nothrow)
    {
        constexpr BlockLength offset = 86;
 
        setOrdinary(offset, convert<timestampToTicks>(value));
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto timePriority() const noexcept(ticksToTimestamp::Nothrow)
    {
        constexpr BlockLength offset = 94;
        return convertible<ticksToTimestamp>(offset);
    }

    ThisType& timePriority(Timestamp value) noexcept(timestampToTicks::Nothrow)
    {
        constexpr BlockLength offset = 94;
 
        setOrdinary(offset, convert<timestampToTicks>(value));
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto orderStatus() const noexcept
    {
        constexpr BlockLength offset = 102;
 
        return enumeration<OrderStatusEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& orderStatus(OrderStatusEnum value) noexcept
    {
        constexpr BlockLength offset = 102;
 
        setEnumeration<OrderStatusEnum>(offset, value);
        return *this;
    }
 
    ThisType& orderStatus(NullOpt) noexcept
    {
        constexpr BlockLength offset = 102;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto memo() const noexcept
    {
        constexpr BlockLength offset = 103;
        constexpr BlockLength length = 30;
 
        return fixedStr<length>(offset, optional);
    }

    ThisType& memo(StrRef value) noexcept
    {
        constexpr BlockLength offset = 103;
        constexpr BlockLength length = 30;
 
        setFixedStr<length>(offset, value);
        return *this;
    }
 
    ThisType& memo(NullOpt) noexcept
    {
        constexpr BlockLength offset = 103;
        constexpr BlockLength length = 30;
 
        setFixedStr<length>(offset, StrRef());
        return *this;
    }

    constexpr
    static BlockLength minimalBlockLength(ONIXS_ICEBOE_UNUSED SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            133;
    }

    constexpr
    static BlockLength blockLength(SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            minimalBlockLength(version);
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static MessageSize getMinimalVariableFieldsSize(ONIXS_ICEBOE_UNUSED SchemaVersion version)
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            0;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static UInt64 getMaxMessageSize(UInt8) noexcept
    {
        return
            static_cast<UInt64>(MessageHeaderBuilder::Size) +
            blockLength(Schema::Version);
    }

    ThisType& resetVariableFields() noexcept
    {
        return *this;
    }

    ThisType& reset() noexcept
    {
        origOrderId(nullOpt);
        price(nullOpt);
        orderStatus(nullOpt);
        memo(nullOpt);
 
        resetVariableFields();
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef className() noexcept
    {
        return constructStrRef("ExecutionReport_New");
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef fixType() noexcept
    {
        return constructStrRef("8");
    }

    ONIXS_ICEBOE_NODISCARD
    std::string toString() const;

    ONIXS_ICEBOE_NODISCARD
    const void* tail() const noexcept
    {
        return
            toOpaquePtr(
                advanceByBytes(
                    binary(),
                    static_cast<ptrdiff_t>(SbeMessage::blockLength()) +
                        MessageHeader::Size));
    }

    ONIXS_ICEBOE_NODISCARD
    EncodedLength calculateBinarySize() const noexcept
    {
        return
            SbeMessage::calculateBinarySize(tail());
    }
 
private:
    void checkLength(
        EncodedLength length, SchemaVersion version) const
    {
       const EncodedLength minimalRequiredLength =
           minimalBlockLength(version) +
           MessageHeader::Size +
           getMinimalVariableFieldsSize(version);
 
       checkBinaryLength(
           *this, length, minimalRequiredLength);
    }
 
    void checkCompatibility() const
    {
        assert(TemplateId == templateId());
 
        checkSchema<Schema>(schemaId(), version());
        checkLength(bufferSize(), version());
    }
};

struct
ExecutionReport_Modify
: SbeMessage
{
    typedef SchemaTraits Schema;

    typedef ExecutionReport_Modify ThisType;

    enum { TemplateId = 105 };

    ExecutionReport_Modify() = default;

    ExecutionReport_Modify(void* data, EncodedLength length, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        reset();
    }

    ExecutionReport_Modify(void* data, EncodedLength length, NoFieldsInit, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        resetVariableFields();
    }

    ExecutionReport_Modify(void* data, EncodedLength length, NoInit)
      : SbeMessage(data, length)
    {
        checkCompatibility();
    }

    explicit
    ExecutionReport_Modify(const SbeMessage& message)
      : SbeMessage(message)
    {
        assert(message.valid());
 
        checkCompatibility();
    }

    ExecutionReport_Modify(void* data, EncodedLength length, NoInit, NoCheck) noexcept
      : SbeMessage(data, length, NoCheck())
    {
        assert(schemaId() == Schema::Id);
        assert(version() >= Schema::MinimalVersion);
        assert(TemplateId == templateId());
    }

    ONIXS_ICEBOE_NODISCARD
    auto originatorUserId() const noexcept
    {
        constexpr BlockLength offset = 0;
        constexpr BlockLength length = 20;
 
        return fixedStr<length>(offset);
    }

    ThisType& originatorUserId(StrRef value) noexcept
    {
        constexpr BlockLength offset = 0;
        constexpr BlockLength length = 20;
 
        setFixedStr<length>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto execId() const noexcept
    {
        constexpr BlockLength offset = 20;
 
        return ordinary<OrderExecID>(offset);
    }

    ThisType& execId(ChooseValueKind<OrderExecID> value) noexcept
    {
        constexpr BlockLength offset = 20;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto clOrdId() const noexcept
    {
        constexpr BlockLength offset = 40;
 
        return ordinary<Int64>(offset);
    }

    ThisType& clOrdId(Int64 value) noexcept
    {
        constexpr BlockLength offset = 40;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto symbol() const noexcept
    {
        constexpr BlockLength offset = 48;
 
        return ordinary<Int32>(offset);
    }

    ThisType& symbol(Int32 value) noexcept
    {
        constexpr BlockLength offset = 48;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto ordType() const noexcept
    {
        constexpr BlockLength offset = 52;
 
        return enumeration<OrderTypeEnum>(offset);
    }

    ThisType& ordType(OrderTypeEnum value) noexcept
    {
        constexpr BlockLength offset = 52;
 
        setEnumeration<OrderTypeEnum>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto side() const noexcept
    {
        constexpr BlockLength offset = 53;
 
        return enumeration<SideEnum>(offset);
    }

    ThisType& side(SideEnum value) noexcept
    {
        constexpr BlockLength offset = 53;
 
        setEnumeration<SideEnum>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto origOrderId() const noexcept
    {
        constexpr BlockLength offset = 54;
 
        return ordinary<NullOriginalOrderID>(offset, optional);
    }

    ThisType& origOrderId(OriginalOrderID value) noexcept
    {
        constexpr BlockLength offset = 54;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& origOrderId(NullOpt) noexcept
    {
        constexpr BlockLength offset = 54;
 
        setOrdinary(offset, NullOriginalOrderID());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto origClOrdId() const noexcept
    {
        constexpr BlockLength offset = 70;
 
        return ordinary<NullInt64NULL>(offset, optional);
    }

    ThisType& origClOrdId(Int64NULL value) noexcept
    {
        constexpr BlockLength offset = 70;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& origClOrdId(NullOpt) noexcept
    {
        constexpr BlockLength offset = 70;
 
        setOrdinary(offset, NullInt64NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto leavesQty() const noexcept
    {
        constexpr BlockLength offset = 78;
 
        return ordinary<Decimal9>(offset);
    }

    ThisType& leavesQty(Decimal9 value) noexcept
    {
        constexpr BlockLength offset = 78;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto cumQty() const noexcept
    {
        constexpr BlockLength offset = 86;
 
        return ordinary<Decimal9>(offset);
    }

    ThisType& cumQty(Decimal9 value) noexcept
    {
        constexpr BlockLength offset = 86;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto price() const noexcept
    {
        constexpr BlockLength offset = 94;
 
        return ordinary<NullDecimal9>(offset, optional);
    }

    ThisType& price(Decimal9 value) noexcept
    {
        constexpr BlockLength offset = 94;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& price(NullOpt) noexcept
    {
        constexpr BlockLength offset = 94;
 
        setOrdinary(offset, NullDecimal9());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto meAcceptanceTime() const noexcept(ticksToTimestamp::Nothrow)
    {
        constexpr BlockLength offset = 102;
        return convertible<ticksToTimestamp>(offset);
    }

    ThisType& meAcceptanceTime(Timestamp value) noexcept(timestampToTicks::Nothrow)
    {
        constexpr BlockLength offset = 102;
 
        setOrdinary(offset, convert<timestampToTicks>(value));
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto timePriority() const noexcept(ticksToTimestamp::Nothrow)
    {
        constexpr BlockLength offset = 110;
        return convertible<ticksToTimestamp>(offset);
    }

    ThisType& timePriority(Timestamp value) noexcept(timestampToTicks::Nothrow)
    {
        constexpr BlockLength offset = 110;
 
        setOrdinary(offset, convert<timestampToTicks>(value));
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto execType() const noexcept
    {
        constexpr BlockLength offset = 118;
 
        return enumeration<ExecTypeEnum>(offset);
    }

    ThisType& execType(ExecTypeEnum value) noexcept
    {
        constexpr BlockLength offset = 118;
 
        setEnumeration<ExecTypeEnum>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto orderStatus() const noexcept
    {
        constexpr BlockLength offset = 119;
 
        return enumeration<OrderStatusEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& orderStatus(OrderStatusEnum value) noexcept
    {
        constexpr BlockLength offset = 119;
 
        setEnumeration<OrderStatusEnum>(offset, value);
        return *this;
    }
 
    ThisType& orderStatus(NullOpt) noexcept
    {
        constexpr BlockLength offset = 119;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto orderState() const noexcept
    {
        constexpr BlockLength offset = 120;
 
        return enumeration<OrderStateEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& orderState(OrderStateEnum value) noexcept
    {
        constexpr BlockLength offset = 120;
 
        setEnumeration<OrderStateEnum>(offset, value);
        return *this;
    }
 
    ThisType& orderState(NullOpt) noexcept
    {
        constexpr BlockLength offset = 120;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto execRestatementReason() const noexcept
    {
        constexpr BlockLength offset = 121;
 
        return enumeration<ExecRestatementReasonEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& execRestatementReason(ExecRestatementReasonEnum value) noexcept
    {
        constexpr BlockLength offset = 121;
 
        setEnumeration<ExecRestatementReasonEnum>(offset, value);
        return *this;
    }
 
    ThisType& execRestatementReason(NullOpt) noexcept
    {
        constexpr BlockLength offset = 121;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto orderModificationFlags() const noexcept
    {
        constexpr BlockLength offset = 122;
 
        return enumeration<OrderFlags>(offset);
    }

    ThisType& orderModificationFlags(OrderFlags value) noexcept
    {
        constexpr BlockLength offset = 122;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto memo() const noexcept
    {
        constexpr BlockLength offset = 123;
        constexpr BlockLength length = 30;
 
        return fixedStr<length>(offset, optional);
    }

    ThisType& memo(StrRef value) noexcept
    {
        constexpr BlockLength offset = 123;
        constexpr BlockLength length = 30;
 
        setFixedStr<length>(offset, value);
        return *this;
    }
 
    ThisType& memo(NullOpt) noexcept
    {
        constexpr BlockLength offset = 123;
        constexpr BlockLength length = 30;
 
        setFixedStr<length>(offset, StrRef());
        return *this;
    }

    constexpr
    static BlockLength minimalBlockLength(ONIXS_ICEBOE_UNUSED SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            153;
    }

    constexpr
    static BlockLength blockLength(SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            minimalBlockLength(version);
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static MessageSize getMinimalVariableFieldsSize(ONIXS_ICEBOE_UNUSED SchemaVersion version)
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            0;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static UInt64 getMaxMessageSize(UInt8) noexcept
    {
        return
            static_cast<UInt64>(MessageHeaderBuilder::Size) +
            blockLength(Schema::Version);
    }

    ThisType& resetVariableFields() noexcept
    {
        return *this;
    }

    ThisType& reset() noexcept
    {
        origOrderId(nullOpt);
        origClOrdId(nullOpt);
        price(nullOpt);
        orderStatus(nullOpt);
        orderState(nullOpt);
        execRestatementReason(nullOpt);
        memo(nullOpt);
 
        resetVariableFields();
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef className() noexcept
    {
        return constructStrRef("ExecutionReport_Modify");
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef fixType() noexcept
    {
        return constructStrRef("8");
    }

    ONIXS_ICEBOE_NODISCARD
    std::string toString() const;

    ONIXS_ICEBOE_NODISCARD
    const void* tail() const noexcept
    {
        return
            toOpaquePtr(
                advanceByBytes(
                    binary(),
                    static_cast<ptrdiff_t>(SbeMessage::blockLength()) +
                        MessageHeader::Size));
    }

    ONIXS_ICEBOE_NODISCARD
    EncodedLength calculateBinarySize() const noexcept
    {
        return
            SbeMessage::calculateBinarySize(tail());
    }
 
private:
    void checkLength(
        EncodedLength length, SchemaVersion version) const
    {
       const EncodedLength minimalRequiredLength =
           minimalBlockLength(version) +
           MessageHeader::Size +
           getMinimalVariableFieldsSize(version);
 
       checkBinaryLength(
           *this, length, minimalRequiredLength);
    }
 
    void checkCompatibility() const
    {
        assert(TemplateId == templateId());
 
        checkSchema<Schema>(schemaId(), version());
        checkLength(bufferSize(), version());
    }
};

struct
ExecutionReport_Cancel
: SbeMessage
{
    typedef SchemaTraits Schema;

    typedef ExecutionReport_Cancel ThisType;

    enum { TemplateId = 106 };

    ExecutionReport_Cancel() = default;

    ExecutionReport_Cancel(void* data, EncodedLength length, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        reset();
    }

    ExecutionReport_Cancel(void* data, EncodedLength length, NoFieldsInit, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        resetVariableFields();
    }

    ExecutionReport_Cancel(void* data, EncodedLength length, NoInit)
      : SbeMessage(data, length)
    {
        checkCompatibility();
    }

    explicit
    ExecutionReport_Cancel(const SbeMessage& message)
      : SbeMessage(message)
    {
        assert(message.valid());
 
        checkCompatibility();
    }

    ExecutionReport_Cancel(void* data, EncodedLength length, NoInit, NoCheck) noexcept
      : SbeMessage(data, length, NoCheck())
    {
        assert(schemaId() == Schema::Id);
        assert(version() >= Schema::MinimalVersion);
        assert(TemplateId == templateId());
    }

    ONIXS_ICEBOE_NODISCARD
    auto originatorUserId() const noexcept
    {
        constexpr BlockLength offset = 0;
        constexpr BlockLength length = 20;
 
        return fixedStr<length>(offset);
    }

    ThisType& originatorUserId(StrRef value) noexcept
    {
        constexpr BlockLength offset = 0;
        constexpr BlockLength length = 20;
 
        setFixedStr<length>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto execId() const noexcept
    {
        constexpr BlockLength offset = 20;
 
        return ordinary<OrderExecID>(offset);
    }

    ThisType& execId(ChooseValueKind<OrderExecID> value) noexcept
    {
        constexpr BlockLength offset = 20;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto clOrdId() const noexcept
    {
        constexpr BlockLength offset = 40;
 
        return ordinary<Int64>(offset);
    }

    ThisType& clOrdId(Int64 value) noexcept
    {
        constexpr BlockLength offset = 40;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto symbol() const noexcept
    {
        constexpr BlockLength offset = 48;
 
        return ordinary<Int32>(offset);
    }

    ThisType& symbol(Int32 value) noexcept
    {
        constexpr BlockLength offset = 48;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto ordType() const noexcept
    {
        constexpr BlockLength offset = 52;
 
        return enumeration<OrderTypeEnum>(offset);
    }

    ThisType& ordType(OrderTypeEnum value) noexcept
    {
        constexpr BlockLength offset = 52;
 
        setEnumeration<OrderTypeEnum>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto side() const noexcept
    {
        constexpr BlockLength offset = 53;
 
        return enumeration<SideEnum>(offset);
    }

    ThisType& side(SideEnum value) noexcept
    {
        constexpr BlockLength offset = 53;
 
        setEnumeration<SideEnum>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto origOrderId() const noexcept
    {
        constexpr BlockLength offset = 54;
 
        return ordinary<NullOriginalOrderID>(offset, optional);
    }

    ThisType& origOrderId(OriginalOrderID value) noexcept
    {
        constexpr BlockLength offset = 54;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& origOrderId(NullOpt) noexcept
    {
        constexpr BlockLength offset = 54;
 
        setOrdinary(offset, NullOriginalOrderID());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto origClOrdId() const noexcept
    {
        constexpr BlockLength offset = 70;
 
        return ordinary<NullInt64NULL>(offset, optional);
    }

    ThisType& origClOrdId(Int64NULL value) noexcept
    {
        constexpr BlockLength offset = 70;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& origClOrdId(NullOpt) noexcept
    {
        constexpr BlockLength offset = 70;
 
        setOrdinary(offset, NullInt64NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto meAcceptanceTime() const noexcept(ticksToTimestamp::Nothrow)
    {
        constexpr BlockLength offset = 78;
        return convertible<ticksToTimestamp>(offset);
    }

    ThisType& meAcceptanceTime(Timestamp value) noexcept(timestampToTicks::Nothrow)
    {
        constexpr BlockLength offset = 78;
 
        setOrdinary(offset, convert<timestampToTicks>(value));
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto exchangeCode() const noexcept
    {
        constexpr BlockLength offset = 86;
 
        return ordinary<NullInt32NULL>(offset, optional);
    }

    ThisType& exchangeCode(Int32NULL value) noexcept
    {
        constexpr BlockLength offset = 86;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& exchangeCode(NullOpt) noexcept
    {
        constexpr BlockLength offset = 86;
 
        setOrdinary(offset, NullInt32NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto cancelReason() const noexcept
    {
        constexpr BlockLength offset = 90;
 
        return enumeration<CancelReasonEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& cancelReason(CancelReasonEnum value) noexcept
    {
        constexpr BlockLength offset = 90;
 
        setEnumeration<CancelReasonEnum>(offset, value);
        return *this;
    }
 
    ThisType& cancelReason(NullOpt) noexcept
    {
        constexpr BlockLength offset = 90;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto crossId() const noexcept
    {
        constexpr BlockLength offset = 91;
 
        return ordinary<NullInt64NULL>(offset, optional);
    }

    ThisType& crossId(Int64NULL value) noexcept
    {
        constexpr BlockLength offset = 91;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& crossId(NullOpt) noexcept
    {
        constexpr BlockLength offset = 91;
 
        setOrdinary(offset, NullInt64NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto text() const noexcept
    {
        constexpr BlockLength offset = 99;
        constexpr BlockLength length = 100;
 
        return fixedStr<length>(offset, optional);
    }

    ThisType& text(StrRef value) noexcept
    {
        constexpr BlockLength offset = 99;
        constexpr BlockLength length = 100;
 
        setFixedStr<length>(offset, value);
        return *this;
    }
 
    ThisType& text(NullOpt) noexcept
    {
        constexpr BlockLength offset = 99;
        constexpr BlockLength length = 100;
 
        setFixedStr<length>(offset, StrRef());
        return *this;
    }

    constexpr
    static BlockLength minimalBlockLength(ONIXS_ICEBOE_UNUSED SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            199;
    }

    constexpr
    static BlockLength blockLength(SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            minimalBlockLength(version);
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static MessageSize getMinimalVariableFieldsSize(ONIXS_ICEBOE_UNUSED SchemaVersion version)
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            0;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static UInt64 getMaxMessageSize(UInt8) noexcept
    {
        return
            static_cast<UInt64>(MessageHeaderBuilder::Size) +
            blockLength(Schema::Version);
    }

    ThisType& resetVariableFields() noexcept
    {
        return *this;
    }

    ThisType& reset() noexcept
    {
        origOrderId(nullOpt);
        origClOrdId(nullOpt);
        exchangeCode(nullOpt);
        cancelReason(nullOpt);
        crossId(nullOpt);
        text(nullOpt);
 
        resetVariableFields();
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef className() noexcept
    {
        return constructStrRef("ExecutionReport_Cancel");
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef fixType() noexcept
    {
        return constructStrRef("8");
    }

    ONIXS_ICEBOE_NODISCARD
    std::string toString() const;

    ONIXS_ICEBOE_NODISCARD
    const void* tail() const noexcept
    {
        return
            toOpaquePtr(
                advanceByBytes(
                    binary(),
                    static_cast<ptrdiff_t>(SbeMessage::blockLength()) +
                        MessageHeader::Size));
    }

    ONIXS_ICEBOE_NODISCARD
    EncodedLength calculateBinarySize() const noexcept
    {
        return
            SbeMessage::calculateBinarySize(tail());
    }
 
private:
    void checkLength(
        EncodedLength length, SchemaVersion version) const
    {
       const EncodedLength minimalRequiredLength =
           minimalBlockLength(version) +
           MessageHeader::Size +
           getMinimalVariableFieldsSize(version);
 
       checkBinaryLength(
           *this, length, minimalRequiredLength);
    }
 
    void checkCompatibility() const
    {
        assert(TemplateId == templateId());
 
        checkSchema<Schema>(schemaId(), version());
        checkLength(bufferSize(), version());
    }
};

struct
ExecutionReport_Reject
: SbeMessage
{
    typedef SchemaTraits Schema;

    typedef ExecutionReport_Reject ThisType;

    enum { TemplateId = 151 };

    ExecutionReport_Reject() = default;

    ExecutionReport_Reject(void* data, EncodedLength length, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        reset();
    }

    ExecutionReport_Reject(void* data, EncodedLength length, NoFieldsInit, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        resetVariableFields();
    }

    ExecutionReport_Reject(void* data, EncodedLength length, NoInit)
      : SbeMessage(data, length)
    {
        checkCompatibility();
    }

    explicit
    ExecutionReport_Reject(const SbeMessage& message)
      : SbeMessage(message)
    {
        assert(message.valid());
 
        checkCompatibility();
    }

    ExecutionReport_Reject(void* data, EncodedLength length, NoInit, NoCheck) noexcept
      : SbeMessage(data, length, NoCheck())
    {
        assert(schemaId() == Schema::Id);
        assert(version() >= Schema::MinimalVersion);
        assert(TemplateId == templateId());
    }

    ONIXS_ICEBOE_NODISCARD
    auto originatorUserId() const noexcept
    {
        constexpr BlockLength offset = 0;
        constexpr BlockLength length = 20;
 
        return fixedStr<length>(offset);
    }

    ThisType& originatorUserId(StrRef value) noexcept
    {
        constexpr BlockLength offset = 0;
        constexpr BlockLength length = 20;
 
        setFixedStr<length>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto execId() const noexcept
    {
        constexpr BlockLength offset = 20;
 
        return ordinary<OrderExecID>(offset);
    }

    ThisType& execId(ChooseValueKind<OrderExecID> value) noexcept
    {
        constexpr BlockLength offset = 20;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto clOrdId() const noexcept
    {
        constexpr BlockLength offset = 40;
 
        return ordinary<Int64>(offset);
    }

    ThisType& clOrdId(Int64 value) noexcept
    {
        constexpr BlockLength offset = 40;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto symbol() const noexcept
    {
        constexpr BlockLength offset = 48;
 
        return ordinary<Int32>(offset);
    }

    ThisType& symbol(Int32 value) noexcept
    {
        constexpr BlockLength offset = 48;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto ordType() const noexcept
    {
        constexpr BlockLength offset = 52;
 
        return enumeration<OrderTypeEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& ordType(OrderTypeEnum value) noexcept
    {
        constexpr BlockLength offset = 52;
 
        setEnumeration<OrderTypeEnum>(offset, value);
        return *this;
    }
 
    ThisType& ordType(NullOpt) noexcept
    {
        constexpr BlockLength offset = 52;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto side() const noexcept
    {
        constexpr BlockLength offset = 53;
 
        return enumeration<SideEnum>(offset);
    }

    ThisType& side(SideEnum value) noexcept
    {
        constexpr BlockLength offset = 53;
 
        setEnumeration<SideEnum>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto origOrderId() const noexcept
    {
        constexpr BlockLength offset = 54;
 
        return ordinary<NullOriginalOrderID>(offset, optional);
    }

    ThisType& origOrderId(OriginalOrderID value) noexcept
    {
        constexpr BlockLength offset = 54;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& origOrderId(NullOpt) noexcept
    {
        constexpr BlockLength offset = 54;
 
        setOrdinary(offset, NullOriginalOrderID());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto origClOrdId() const noexcept
    {
        constexpr BlockLength offset = 70;
 
        return ordinary<NullInt64NULL>(offset, optional);
    }

    ThisType& origClOrdId(Int64NULL value) noexcept
    {
        constexpr BlockLength offset = 70;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& origClOrdId(NullOpt) noexcept
    {
        constexpr BlockLength offset = 70;
 
        setOrdinary(offset, NullInt64NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto orderStatus() const noexcept
    {
        constexpr BlockLength offset = 78;
 
        return enumeration<OrderStatusEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& orderStatus(OrderStatusEnum value) noexcept
    {
        constexpr BlockLength offset = 78;
 
        setEnumeration<OrderStatusEnum>(offset, value);
        return *this;
    }
 
    ThisType& orderStatus(NullOpt) noexcept
    {
        constexpr BlockLength offset = 78;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto rejectResponseTo() const noexcept
    {
        constexpr BlockLength offset = 79;
 
        return enumeration<RejectResponseToEnum>(offset);
    }

    ThisType& rejectResponseTo(RejectResponseToEnum value) noexcept
    {
        constexpr BlockLength offset = 79;
 
        setEnumeration<RejectResponseToEnum>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto rejectReason() const noexcept
    {
        constexpr BlockLength offset = 80;
 
        return enumeration<RejectEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& rejectReason(RejectEnum value) noexcept
    {
        constexpr BlockLength offset = 80;
 
        setEnumeration<RejectEnum>(offset, value);
        return *this;
    }
 
    ThisType& rejectReason(NullOpt) noexcept
    {
        constexpr BlockLength offset = 80;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto exchangeCode() const noexcept
    {
        constexpr BlockLength offset = 81;
 
        return ordinary<NullInt32NULL>(offset, optional);
    }

    ThisType& exchangeCode(Int32NULL value) noexcept
    {
        constexpr BlockLength offset = 81;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& exchangeCode(NullOpt) noexcept
    {
        constexpr BlockLength offset = 81;
 
        setOrdinary(offset, NullInt32NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto memo() const noexcept
    {
        constexpr BlockLength offset = 85;
        constexpr BlockLength length = 30;
 
        return fixedStr<length>(offset, optional);
    }

    ThisType& memo(StrRef value) noexcept
    {
        constexpr BlockLength offset = 85;
        constexpr BlockLength length = 30;
 
        setFixedStr<length>(offset, value);
        return *this;
    }
 
    ThisType& memo(NullOpt) noexcept
    {
        constexpr BlockLength offset = 85;
        constexpr BlockLength length = 30;
 
        setFixedStr<length>(offset, StrRef());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto text() const noexcept
    {
        constexpr BlockLength offset = 115;
        constexpr BlockLength length = 100;
 
        return fixedStr<length>(offset, optional);
    }

    ThisType& text(StrRef value) noexcept
    {
        constexpr BlockLength offset = 115;
        constexpr BlockLength length = 100;
 
        setFixedStr<length>(offset, value);
        return *this;
    }
 
    ThisType& text(NullOpt) noexcept
    {
        constexpr BlockLength offset = 115;
        constexpr BlockLength length = 100;
 
        setFixedStr<length>(offset, StrRef());
        return *this;
    }

    constexpr
    static BlockLength minimalBlockLength(ONIXS_ICEBOE_UNUSED SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            215;
    }

    constexpr
    static BlockLength blockLength(SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            minimalBlockLength(version);
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static MessageSize getMinimalVariableFieldsSize(ONIXS_ICEBOE_UNUSED SchemaVersion version)
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            0;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static UInt64 getMaxMessageSize(UInt8) noexcept
    {
        return
            static_cast<UInt64>(MessageHeaderBuilder::Size) +
            blockLength(Schema::Version);
    }

    ThisType& resetVariableFields() noexcept
    {
        return *this;
    }

    ThisType& reset() noexcept
    {
        ordType(nullOpt);
        origOrderId(nullOpt);
        origClOrdId(nullOpt);
        orderStatus(nullOpt);
        rejectReason(nullOpt);
        exchangeCode(nullOpt);
        memo(nullOpt);
        text(nullOpt);
 
        resetVariableFields();
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef className() noexcept
    {
        return constructStrRef("ExecutionReport_Reject");
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef fixType() noexcept
    {
        return constructStrRef("8");
    }

    ONIXS_ICEBOE_NODISCARD
    std::string toString() const;

    ONIXS_ICEBOE_NODISCARD
    const void* tail() const noexcept
    {
        return
            toOpaquePtr(
                advanceByBytes(
                    binary(),
                    static_cast<ptrdiff_t>(SbeMessage::blockLength()) +
                        MessageHeader::Size));
    }

    ONIXS_ICEBOE_NODISCARD
    EncodedLength calculateBinarySize() const noexcept
    {
        return
            SbeMessage::calculateBinarySize(tail());
    }
 
private:
    void checkLength(
        EncodedLength length, SchemaVersion version) const
    {
       const EncodedLength minimalRequiredLength =
           minimalBlockLength(version) +
           MessageHeader::Size +
           getMinimalVariableFieldsSize(version);
 
       checkBinaryLength(
           *this, length, minimalRequiredLength);
    }
 
    void checkCompatibility() const
    {
        assert(TemplateId == templateId());
 
        checkSchema<Schema>(schemaId(), version());
        checkLength(bufferSize(), version());
    }
};

struct
ExecutionReport_Snapshot
: SbeMessage
{
    typedef SchemaTraits Schema;

    typedef ExecutionReport_Snapshot ThisType;

    enum { TemplateId = 152 };

    ExecutionReport_Snapshot() = default;

    ExecutionReport_Snapshot(void* data, EncodedLength length, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        reset();
    }

    ExecutionReport_Snapshot(void* data, EncodedLength length, NoFieldsInit, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        resetVariableFields();
    }

    ExecutionReport_Snapshot(void* data, EncodedLength length, NoInit)
      : SbeMessage(data, length)
    {
        checkCompatibility();
    }

    explicit
    ExecutionReport_Snapshot(const SbeMessage& message)
      : SbeMessage(message)
    {
        assert(message.valid());
 
        checkCompatibility();
    }

    ExecutionReport_Snapshot(void* data, EncodedLength length, NoInit, NoCheck) noexcept
      : SbeMessage(data, length, NoCheck())
    {
        assert(schemaId() == Schema::Id);
        assert(version() >= Schema::MinimalVersion);
        assert(TemplateId == templateId());
    }

    ONIXS_ICEBOE_NODISCARD
    auto originatorUserId() const noexcept
    {
        constexpr BlockLength offset = 0;
        constexpr BlockLength length = 20;
 
        return fixedStr<length>(offset);
    }

    ThisType& originatorUserId(StrRef value) noexcept
    {
        constexpr BlockLength offset = 0;
        constexpr BlockLength length = 20;
 
        setFixedStr<length>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto execId() const noexcept
    {
        constexpr BlockLength offset = 20;
 
        return ordinary<OrderExecID>(offset);
    }

    ThisType& execId(ChooseValueKind<OrderExecID> value) noexcept
    {
        constexpr BlockLength offset = 20;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto clOrdId() const noexcept
    {
        constexpr BlockLength offset = 40;
 
        return ordinary<Int64>(offset);
    }

    ThisType& clOrdId(Int64 value) noexcept
    {
        constexpr BlockLength offset = 40;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto symbol() const noexcept
    {
        constexpr BlockLength offset = 48;
 
        return ordinary<Int32>(offset);
    }

    ThisType& symbol(Int32 value) noexcept
    {
        constexpr BlockLength offset = 48;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto ordType() const noexcept
    {
        constexpr BlockLength offset = 52;
 
        return enumeration<OrderTypeEnum>(offset);
    }

    ThisType& ordType(OrderTypeEnum value) noexcept
    {
        constexpr BlockLength offset = 52;
 
        setEnumeration<OrderTypeEnum>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto side() const noexcept
    {
        constexpr BlockLength offset = 53;
 
        return enumeration<SideEnum>(offset);
    }

    ThisType& side(SideEnum value) noexcept
    {
        constexpr BlockLength offset = 53;
 
        setEnumeration<SideEnum>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto origOrderId() const noexcept
    {
        constexpr BlockLength offset = 54;
 
        return ordinary<NullOriginalOrderID>(offset, optional);
    }

    ThisType& origOrderId(OriginalOrderID value) noexcept
    {
        constexpr BlockLength offset = 54;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& origOrderId(NullOpt) noexcept
    {
        constexpr BlockLength offset = 54;
 
        setOrdinary(offset, NullOriginalOrderID());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto maxShow() const noexcept
    {
        constexpr BlockLength offset = 70;
 
        return ordinary<NullDecimal9>(offset, optional);
    }

    ThisType& maxShow(Decimal9 value) noexcept
    {
        constexpr BlockLength offset = 70;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& maxShow(NullOpt) noexcept
    {
        constexpr BlockLength offset = 70;
 
        setOrdinary(offset, NullDecimal9());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto leavesQty() const noexcept
    {
        constexpr BlockLength offset = 78;
 
        return ordinary<Decimal9>(offset);
    }

    ThisType& leavesQty(Decimal9 value) noexcept
    {
        constexpr BlockLength offset = 78;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto cumQty() const noexcept
    {
        constexpr BlockLength offset = 86;
 
        return ordinary<Decimal9>(offset);
    }

    ThisType& cumQty(Decimal9 value) noexcept
    {
        constexpr BlockLength offset = 86;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto price() const noexcept
    {
        constexpr BlockLength offset = 94;
 
        return ordinary<NullDecimal9>(offset, optional);
    }

    ThisType& price(Decimal9 value) noexcept
    {
        constexpr BlockLength offset = 94;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& price(NullOpt) noexcept
    {
        constexpr BlockLength offset = 94;
 
        setOrdinary(offset, NullDecimal9());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto stopPx() const noexcept
    {
        constexpr BlockLength offset = 102;
 
        return ordinary<NullDecimal9>(offset, optional);
    }

    ThisType& stopPx(Decimal9 value) noexcept
    {
        constexpr BlockLength offset = 102;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& stopPx(NullOpt) noexcept
    {
        constexpr BlockLength offset = 102;
 
        setOrdinary(offset, NullDecimal9());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto expireDate() const noexcept(dateToTimestamp::Nothrow)
    {
        constexpr BlockLength offset = 110;
        return convertible<NullUTCDateOnly, dateToTimestamp>(offset, optional);
    }

    ThisType& expireDate(Timestamp value) noexcept(timestampToDate::Nothrow)
    {
        constexpr BlockLength offset = 110;
 
        setOrdinary(offset, convert<timestampToDate>(value));
        return *this;
    }
 
    ThisType& expireDate(NullOpt) noexcept
    {
        constexpr BlockLength offset = 110;
 
        setOrdinary(offset, NullUTCDateOnly());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto timePriority() const noexcept(ticksToTimestamp::Nothrow)
    {
        constexpr BlockLength offset = 112;
        return convertible<ticksToTimestamp>(offset);
    }

    ThisType& timePriority(Timestamp value) noexcept(timestampToTicks::Nothrow)
    {
        constexpr BlockLength offset = 112;
 
        setOrdinary(offset, convert<timestampToTicks>(value));
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto timeInForce() const noexcept
    {
        constexpr BlockLength offset = 120;
 
        return enumeration<TimeInForceEnum>(offset);
    }

    ThisType& timeInForce(TimeInForceEnum value) noexcept
    {
        constexpr BlockLength offset = 120;
 
        setEnumeration<TimeInForceEnum>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto orderStatus() const noexcept
    {
        constexpr BlockLength offset = 121;
 
        return enumeration<OrderStatusEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& orderStatus(OrderStatusEnum value) noexcept
    {
        constexpr BlockLength offset = 121;
 
        setEnumeration<OrderStatusEnum>(offset, value);
        return *this;
    }
 
    ThisType& orderStatus(NullOpt) noexcept
    {
        constexpr BlockLength offset = 121;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto orderState() const noexcept
    {
        constexpr BlockLength offset = 122;
 
        return enumeration<OrderStateEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& orderState(OrderStateEnum value) noexcept
    {
        constexpr BlockLength offset = 122;
 
        setEnumeration<OrderStateEnum>(offset, value);
        return *this;
    }
 
    ThisType& orderState(NullOpt) noexcept
    {
        constexpr BlockLength offset = 122;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto giveUpClearingFirm() const noexcept
    {
        constexpr BlockLength offset = 123;
 
        return ordinary<NullInt32NULL>(offset, optional);
    }

    ThisType& giveUpClearingFirm(Int32NULL value) noexcept
    {
        constexpr BlockLength offset = 123;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& giveUpClearingFirm(NullOpt) noexcept
    {
        constexpr BlockLength offset = 123;
 
        setOrdinary(offset, NullInt32NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto clearingFirm() const noexcept
    {
        constexpr BlockLength offset = 127;
 
        return ordinary<NullInt32NULL>(offset, optional);
    }

    ThisType& clearingFirm(Int32NULL value) noexcept
    {
        constexpr BlockLength offset = 127;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& clearingFirm(NullOpt) noexcept
    {
        constexpr BlockLength offset = 127;
 
        setOrdinary(offset, NullInt32NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto directElectronicAccess() const noexcept
    {
        constexpr BlockLength offset = 131;
 
        return enumeration<BooleanEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& directElectronicAccess(BooleanEnum value) noexcept
    {
        constexpr BlockLength offset = 131;
 
        setEnumeration<BooleanEnum>(offset, value);
        return *this;
    }
 
    ThisType& directElectronicAccess(NullOpt) noexcept
    {
        constexpr BlockLength offset = 131;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto tradingCapacity() const noexcept
    {
        constexpr BlockLength offset = 132;
 
        return enumeration<TradingCapacityEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& tradingCapacity(TradingCapacityEnum value) noexcept
    {
        constexpr BlockLength offset = 132;
 
        setEnumeration<TradingCapacityEnum>(offset, value);
        return *this;
    }
 
    ThisType& tradingCapacity(NullOpt) noexcept
    {
        constexpr BlockLength offset = 132;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto liquidityProvision() const noexcept
    {
        constexpr BlockLength offset = 133;
 
        return enumeration<BooleanEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& liquidityProvision(BooleanEnum value) noexcept
    {
        constexpr BlockLength offset = 133;
 
        setEnumeration<BooleanEnum>(offset, value);
        return *this;
    }
 
    ThisType& liquidityProvision(NullOpt) noexcept
    {
        constexpr BlockLength offset = 133;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto commodityDerivIndicator() const noexcept
    {
        constexpr BlockLength offset = 134;
 
        return enumeration<BooleanEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& commodityDerivIndicator(BooleanEnum value) noexcept
    {
        constexpr BlockLength offset = 134;
 
        setEnumeration<BooleanEnum>(offset, value);
        return *this;
    }
 
    ThisType& commodityDerivIndicator(NullOpt) noexcept
    {
        constexpr BlockLength offset = 134;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto investmentDecision() const noexcept
    {
        constexpr BlockLength offset = 135;
 
        return ordinary<NullInt64NULL>(offset, optional);
    }

    ThisType& investmentDecision(Int64NULL value) noexcept
    {
        constexpr BlockLength offset = 135;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& investmentDecision(NullOpt) noexcept
    {
        constexpr BlockLength offset = 135;
 
        setOrdinary(offset, NullInt64NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto executionDecision() const noexcept
    {
        constexpr BlockLength offset = 143;
 
        return ordinary<NullInt64NULL>(offset, optional);
    }

    ThisType& executionDecision(Int64NULL value) noexcept
    {
        constexpr BlockLength offset = 143;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& executionDecision(NullOpt) noexcept
    {
        constexpr BlockLength offset = 143;
 
        setOrdinary(offset, NullInt64NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto clientIdCode() const noexcept
    {
        constexpr BlockLength offset = 151;
 
        return ordinary<NullInt64NULL>(offset, optional);
    }

    ThisType& clientIdCode(Int64NULL value) noexcept
    {
        constexpr BlockLength offset = 151;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& clientIdCode(NullOpt) noexcept
    {
        constexpr BlockLength offset = 151;
 
        setOrdinary(offset, NullInt64NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto mifidId() const noexcept
    {
        constexpr BlockLength offset = 159;
 
        return ordinary<NullInt64NULL>(offset, optional);
    }

    ThisType& mifidId(Int64NULL value) noexcept
    {
        constexpr BlockLength offset = 159;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& mifidId(NullOpt) noexcept
    {
        constexpr BlockLength offset = 159;
 
        setOrdinary(offset, NullInt64NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto selfMatchPreventionId() const noexcept
    {
        constexpr BlockLength offset = 167;
 
        return ordinary<NullInt64NULL>(offset, optional);
    }

    ThisType& selfMatchPreventionId(Int64NULL value) noexcept
    {
        constexpr BlockLength offset = 167;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& selfMatchPreventionId(NullOpt) noexcept
    {
        constexpr BlockLength offset = 167;
 
        setOrdinary(offset, NullInt64NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto selfMatchPreventionInstruction() const noexcept
    {
        constexpr BlockLength offset = 175;
 
        return enumeration<SelfMatchPreventionInstructionEnum, NullCharType>(offset, optional);
    }

    ThisType& selfMatchPreventionInstruction(SelfMatchPreventionInstructionEnum value) noexcept
    {
        constexpr BlockLength offset = 175;
 
        setEnumeration<SelfMatchPreventionInstructionEnum>(offset, value);
        return *this;
    }
 
    ThisType& selfMatchPreventionInstruction(NullOpt) noexcept
    {
        constexpr BlockLength offset = 175;
 
        setOrdinary(offset, NullCharType());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto manualOrderIndicator() const noexcept
    {
        constexpr BlockLength offset = 176;
 
        return enumeration<BooleanEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& manualOrderIndicator(BooleanEnum value) noexcept
    {
        constexpr BlockLength offset = 176;
 
        setEnumeration<BooleanEnum>(offset, value);
        return *this;
    }
 
    ThisType& manualOrderIndicator(NullOpt) noexcept
    {
        constexpr BlockLength offset = 176;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto execInst() const noexcept
    {
        constexpr BlockLength offset = 177;
 
        return enumeration<ExecInstEnum, NullCharType>(offset, optional);
    }

    ThisType& execInst(ExecInstEnum value) noexcept
    {
        constexpr BlockLength offset = 177;
 
        setEnumeration<ExecInstEnum>(offset, value);
        return *this;
    }
 
    ThisType& execInst(NullOpt) noexcept
    {
        constexpr BlockLength offset = 177;
 
        setOrdinary(offset, NullCharType());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto custOrderHandlingInst() const noexcept
    {
        constexpr BlockLength offset = 178;
 
        return enumeration<CustOrderHandlingInstEnum, NullCharType>(offset, optional);
    }

    ThisType& custOrderHandlingInst(CustOrderHandlingInstEnum value) noexcept
    {
        constexpr BlockLength offset = 178;
 
        setEnumeration<CustOrderHandlingInstEnum>(offset, value);
        return *this;
    }
 
    ThisType& custOrderHandlingInst(NullOpt) noexcept
    {
        constexpr BlockLength offset = 178;
 
        setOrdinary(offset, NullCharType());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto positionEffect() const noexcept
    {
        constexpr BlockLength offset = 179;
 
        return enumeration<PositionEffectEnum, NullCharType>(offset, optional);
    }

    ThisType& positionEffect(PositionEffectEnum value) noexcept
    {
        constexpr BlockLength offset = 179;
 
        setEnumeration<PositionEffectEnum>(offset, value);
        return *this;
    }
 
    ThisType& positionEffect(NullOpt) noexcept
    {
        constexpr BlockLength offset = 179;
 
        setOrdinary(offset, NullCharType());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto allocHandlInst() const noexcept
    {
        constexpr BlockLength offset = 180;
 
        return enumeration<AllocHandlInstEnum, NullCharType>(offset, optional);
    }

    ThisType& allocHandlInst(AllocHandlInstEnum value) noexcept
    {
        constexpr BlockLength offset = 180;
 
        setEnumeration<AllocHandlInstEnum>(offset, value);
        return *this;
    }
 
    ThisType& allocHandlInst(NullOpt) noexcept
    {
        constexpr BlockLength offset = 180;
 
        setOrdinary(offset, NullCharType());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto clearingAccount() const noexcept
    {
        constexpr BlockLength offset = 181;
        constexpr BlockLength length = 14;
 
        return fixedStr<length>(offset, optional);
    }

    ThisType& clearingAccount(StrRef value) noexcept
    {
        constexpr BlockLength offset = 181;
        constexpr BlockLength length = 14;
 
        setFixedStr<length>(offset, value);
        return *this;
    }
 
    ThisType& clearingAccount(NullOpt) noexcept
    {
        constexpr BlockLength offset = 181;
        constexpr BlockLength length = 14;
 
        setFixedStr<length>(offset, StrRef());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto customerAccountRefId() const noexcept
    {
        constexpr BlockLength offset = 195;
        constexpr BlockLength length = 12;
 
        return fixedStr<length>(offset, optional);
    }

    ThisType& customerAccountRefId(StrRef value) noexcept
    {
        constexpr BlockLength offset = 195;
        constexpr BlockLength length = 12;
 
        setFixedStr<length>(offset, value);
        return *this;
    }
 
    ThisType& customerAccountRefId(NullOpt) noexcept
    {
        constexpr BlockLength offset = 195;
        constexpr BlockLength length = 12;
 
        setFixedStr<length>(offset, StrRef());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto memo() const noexcept
    {
        constexpr BlockLength offset = 207;
        constexpr BlockLength length = 30;
 
        return fixedStr<length>(offset, optional);
    }

    ThisType& memo(StrRef value) noexcept
    {
        constexpr BlockLength offset = 207;
        constexpr BlockLength length = 30;
 
        setFixedStr<length>(offset, value);
        return *this;
    }
 
    ThisType& memo(NullOpt) noexcept
    {
        constexpr BlockLength offset = 207;
        constexpr BlockLength length = 30;
 
        setFixedStr<length>(offset, StrRef());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto allocationAccount() const noexcept
    {
        constexpr BlockLength offset = 237;
        constexpr BlockLength length = 20;
 
        return fixedStr<length>(offset, optional);
    }

    ThisType& allocationAccount(StrRef value) noexcept
    {
        constexpr BlockLength offset = 237;
        constexpr BlockLength length = 20;
 
        setFixedStr<length>(offset, value);
        return *this;
    }
 
    ThisType& allocationAccount(NullOpt) noexcept
    {
        constexpr BlockLength offset = 237;
        constexpr BlockLength length = 20;
 
        setFixedStr<length>(offset, StrRef());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto onBehalfOfCompId() const noexcept
    {
        constexpr BlockLength offset = 257;
        constexpr BlockLength length = 41;
 
        return fixedStr<length>(offset, optional);
    }

    ThisType& onBehalfOfCompId(StrRef value) noexcept
    {
        constexpr BlockLength offset = 257;
        constexpr BlockLength length = 41;
 
        setFixedStr<length>(offset, value);
        return *this;
    }
 
    ThisType& onBehalfOfCompId(NullOpt) noexcept
    {
        constexpr BlockLength offset = 257;
        constexpr BlockLength length = 41;
 
        setFixedStr<length>(offset, StrRef());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto onBehalfOfSubId() const noexcept
    {
        constexpr BlockLength offset = 298;
        constexpr BlockLength length = 41;
 
        return fixedStr<length>(offset, optional);
    }

    ThisType& onBehalfOfSubId(StrRef value) noexcept
    {
        constexpr BlockLength offset = 298;
        constexpr BlockLength length = 41;
 
        setFixedStr<length>(offset, value);
        return *this;
    }
 
    ThisType& onBehalfOfSubId(NullOpt) noexcept
    {
        constexpr BlockLength offset = 298;
        constexpr BlockLength length = 41;
 
        setFixedStr<length>(offset, StrRef());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto onBehalfOfLocationId() const noexcept
    {
        constexpr BlockLength offset = 339;
        constexpr BlockLength length = 41;
 
        return fixedStr<length>(offset, optional);
    }

    ThisType& onBehalfOfLocationId(StrRef value) noexcept
    {
        constexpr BlockLength offset = 339;
        constexpr BlockLength length = 41;
 
        setFixedStr<length>(offset, value);
        return *this;
    }
 
    ThisType& onBehalfOfLocationId(NullOpt) noexcept
    {
        constexpr BlockLength offset = 339;
        constexpr BlockLength length = 41;
 
        setFixedStr<length>(offset, StrRef());
        return *this;
    }

    constexpr
    static BlockLength minimalBlockLength(ONIXS_ICEBOE_UNUSED SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            380;
    }

    constexpr
    static BlockLength blockLength(SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            minimalBlockLength(version);
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static MessageSize getMinimalVariableFieldsSize(ONIXS_ICEBOE_UNUSED SchemaVersion version)
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            0;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static UInt64 getMaxMessageSize(UInt8) noexcept
    {
        return
            static_cast<UInt64>(MessageHeaderBuilder::Size) +
            blockLength(Schema::Version);
    }

    ThisType& resetVariableFields() noexcept
    {
        return *this;
    }

    ThisType& reset() noexcept
    {
        origOrderId(nullOpt);
        maxShow(nullOpt);
        price(nullOpt);
        stopPx(nullOpt);
        expireDate(nullOpt);
        orderStatus(nullOpt);
        orderState(nullOpt);
        giveUpClearingFirm(nullOpt);
        clearingFirm(nullOpt);
        directElectronicAccess(nullOpt);
        tradingCapacity(nullOpt);
        liquidityProvision(nullOpt);
        commodityDerivIndicator(nullOpt);
        investmentDecision(nullOpt);
        executionDecision(nullOpt);
        clientIdCode(nullOpt);
        mifidId(nullOpt);
        selfMatchPreventionId(nullOpt);
        selfMatchPreventionInstruction(nullOpt);
        manualOrderIndicator(nullOpt);
        execInst(nullOpt);
        custOrderHandlingInst(nullOpt);
        positionEffect(nullOpt);
        allocHandlInst(nullOpt);
        clearingAccount(nullOpt);
        customerAccountRefId(nullOpt);
        memo(nullOpt);
        allocationAccount(nullOpt);
        onBehalfOfCompId(nullOpt);
        onBehalfOfSubId(nullOpt);
        onBehalfOfLocationId(nullOpt);
 
        resetVariableFields();
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef className() noexcept
    {
        return constructStrRef("ExecutionReport_Snapshot");
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef fixType() noexcept
    {
        return constructStrRef("8");
    }

    ONIXS_ICEBOE_NODISCARD
    std::string toString() const;

    ONIXS_ICEBOE_NODISCARD
    const void* tail() const noexcept
    {
        return
            toOpaquePtr(
                advanceByBytes(
                    binary(),
                    static_cast<ptrdiff_t>(SbeMessage::blockLength()) +
                        MessageHeader::Size));
    }

    ONIXS_ICEBOE_NODISCARD
    EncodedLength calculateBinarySize() const noexcept
    {
        return
            SbeMessage::calculateBinarySize(tail());
    }
 
private:
    void checkLength(
        EncodedLength length, SchemaVersion version) const
    {
       const EncodedLength minimalRequiredLength =
           minimalBlockLength(version) +
           MessageHeader::Size +
           getMinimalVariableFieldsSize(version);
 
       checkBinaryLength(
           *this, length, minimalRequiredLength);
    }
 
    void checkCompatibility() const
    {
        assert(TemplateId == templateId());
 
        checkSchema<Schema>(schemaId(), version());
        checkLength(bufferSize(), version());
    }
};

struct
ExecutionReport_Trade
: SbeMessage
{
    typedef SchemaTraits Schema;

    typedef ExecutionReport_Trade ThisType;

    enum { TemplateId = 153 };

    ExecutionReport_Trade() = default;

    ExecutionReport_Trade(void* data, EncodedLength length, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        reset();
    }

    ExecutionReport_Trade(void* data, EncodedLength length, NoFieldsInit, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        resetVariableFields();
    }

    ExecutionReport_Trade(void* data, EncodedLength length, NoInit)
      : SbeMessage(data, length)
    {
        checkCompatibility();
    }

    explicit
    ExecutionReport_Trade(const SbeMessage& message)
      : SbeMessage(message)
    {
        assert(message.valid());
 
        checkCompatibility();
    }

    ExecutionReport_Trade(void* data, EncodedLength length, NoInit, NoCheck) noexcept
      : SbeMessage(data, length, NoCheck())
    {
        assert(schemaId() == Schema::Id);
        assert(version() >= Schema::MinimalVersion);
        assert(TemplateId == templateId());
    }

    ONIXS_ICEBOE_NODISCARD
    auto originatorUserId() const noexcept
    {
        constexpr BlockLength offset = 0;
        constexpr BlockLength length = 20;
 
        return fixedStr<length>(offset);
    }

    ThisType& originatorUserId(StrRef value) noexcept
    {
        constexpr BlockLength offset = 0;
        constexpr BlockLength length = 20;
 
        setFixedStr<length>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto execId() const noexcept
    {
        constexpr BlockLength offset = 20;
 
        return ordinary<Int64>(offset);
    }

    ThisType& execId(Int64 value) noexcept
    {
        constexpr BlockLength offset = 20;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto clOrdId() const noexcept
    {
        constexpr BlockLength offset = 28;
 
        return ordinary<Int64>(offset);
    }

    ThisType& clOrdId(Int64 value) noexcept
    {
        constexpr BlockLength offset = 28;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto symbol() const noexcept
    {
        constexpr BlockLength offset = 36;
 
        return ordinary<Int32>(offset);
    }

    ThisType& symbol(Int32 value) noexcept
    {
        constexpr BlockLength offset = 36;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto ordType() const noexcept
    {
        constexpr BlockLength offset = 40;
 
        return enumeration<OrderTypeEnum>(offset);
    }

    ThisType& ordType(OrderTypeEnum value) noexcept
    {
        constexpr BlockLength offset = 40;
 
        setEnumeration<OrderTypeEnum>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto side() const noexcept
    {
        constexpr BlockLength offset = 41;
 
        return enumeration<SideEnum>(offset);
    }

    ThisType& side(SideEnum value) noexcept
    {
        constexpr BlockLength offset = 41;
 
        setEnumeration<SideEnum>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto orderId() const noexcept
    {
        constexpr BlockLength offset = 42;
 
        return ordinary<Int64>(offset);
    }

    ThisType& orderId(Int64 value) noexcept
    {
        constexpr BlockLength offset = 42;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto origOrderId() const noexcept
    {
        constexpr BlockLength offset = 50;
 
        return ordinary<NullOriginalOrderID>(offset, optional);
    }

    ThisType& origOrderId(OriginalOrderID value) noexcept
    {
        constexpr BlockLength offset = 50;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& origOrderId(NullOpt) noexcept
    {
        constexpr BlockLength offset = 50;
 
        setOrdinary(offset, NullOriginalOrderID());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto leavesQty() const noexcept
    {
        constexpr BlockLength offset = 66;
 
        return ordinary<Decimal9>(offset);
    }

    ThisType& leavesQty(Decimal9 value) noexcept
    {
        constexpr BlockLength offset = 66;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto cumQty() const noexcept
    {
        constexpr BlockLength offset = 74;
 
        return ordinary<Decimal9>(offset);
    }

    ThisType& cumQty(Decimal9 value) noexcept
    {
        constexpr BlockLength offset = 74;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto lastPx() const noexcept
    {
        constexpr BlockLength offset = 82;
 
        return ordinary<NullDecimal9>(offset, optional);
    }

    ThisType& lastPx(Decimal9 value) noexcept
    {
        constexpr BlockLength offset = 82;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& lastPx(NullOpt) noexcept
    {
        constexpr BlockLength offset = 82;
 
        setOrdinary(offset, NullDecimal9());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto lastShares() const noexcept
    {
        constexpr BlockLength offset = 90;
 
        return ordinary<Decimal9>(offset);
    }

    ThisType& lastShares(Decimal9 value) noexcept
    {
        constexpr BlockLength offset = 90;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto transactTime() const noexcept(ticksToTimestamp::Nothrow)
    {
        constexpr BlockLength offset = 98;
        return convertible<ticksToTimestamp>(offset);
    }

    ThisType& transactTime(Timestamp value) noexcept(timestampToTicks::Nothrow)
    {
        constexpr BlockLength offset = 98;
 
        setOrdinary(offset, convert<timestampToTicks>(value));
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto numOfLots() const noexcept
    {
        constexpr BlockLength offset = 106;
 
        return ordinary<NullInt64NULL>(offset, optional);
    }

    ThisType& numOfLots(Int64NULL value) noexcept
    {
        constexpr BlockLength offset = 106;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& numOfLots(NullOpt) noexcept
    {
        constexpr BlockLength offset = 106;
 
        setOrdinary(offset, NullInt64NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto execType() const noexcept
    {
        constexpr BlockLength offset = 114;
 
        return enumeration<ExecTypeEnum>(offset);
    }

    ThisType& execType(ExecTypeEnum value) noexcept
    {
        constexpr BlockLength offset = 114;
 
        setEnumeration<ExecTypeEnum>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto tradeFlags() const noexcept
    {
        constexpr BlockLength offset = 115;
 
        return enumeration<TradeFlags>(offset);
    }

    ThisType& tradeFlags(TradeFlags value) noexcept
    {
        constexpr BlockLength offset = 115;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto clearingFirm() const noexcept
    {
        constexpr BlockLength offset = 116;
 
        return ordinary<NullInt32NULL>(offset, optional);
    }

    ThisType& clearingFirm(Int32NULL value) noexcept
    {
        constexpr BlockLength offset = 116;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& clearingFirm(NullOpt) noexcept
    {
        constexpr BlockLength offset = 116;
 
        setOrdinary(offset, NullInt32NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto clearingAccount() const noexcept
    {
        constexpr BlockLength offset = 120;
        constexpr BlockLength length = 14;
 
        return fixedStr<length>(offset, optional);
    }

    ThisType& clearingAccount(StrRef value) noexcept
    {
        constexpr BlockLength offset = 120;
        constexpr BlockLength length = 14;
 
        setFixedStr<length>(offset, value);
        return *this;
    }
 
    ThisType& clearingAccount(NullOpt) noexcept
    {
        constexpr BlockLength offset = 120;
        constexpr BlockLength length = 14;
 
        setFixedStr<length>(offset, StrRef());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto memo() const noexcept
    {
        constexpr BlockLength offset = 134;
        constexpr BlockLength length = 30;
 
        return fixedStr<length>(offset, optional);
    }

    ThisType& memo(StrRef value) noexcept
    {
        constexpr BlockLength offset = 134;
        constexpr BlockLength length = 30;
 
        setFixedStr<length>(offset, value);
        return *this;
    }
 
    ThisType& memo(NullOpt) noexcept
    {
        constexpr BlockLength offset = 134;
        constexpr BlockLength length = 30;
 
        setFixedStr<length>(offset, StrRef());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto execRefId() const noexcept
    {
        constexpr BlockLength offset = 164;
 
        return ordinary<NullInt64NULL>(offset, optional);
    }

    ThisType& execRefId(Int64NULL value) noexcept
    {
        constexpr BlockLength offset = 164;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& execRefId(NullOpt) noexcept
    {
        constexpr BlockLength offset = 164;
 
        setOrdinary(offset, NullInt64NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto legExecutions() const noexcept
    {
        constexpr BlockLength offset = 172;
 
        return ordinary<NullInt16NULL>(offset, optional);
    }

    ThisType& legExecutions(Int16NULL value) noexcept
    {
        constexpr BlockLength offset = 172;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& legExecutions(NullOpt) noexcept
    {
        constexpr BlockLength offset = 172;
 
        setOrdinary(offset, NullInt16NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto secondaryExecId() const noexcept
    {
        constexpr BlockLength offset = 174;
 
        return ordinary<NullInt64NULL>(offset, optional);
    }

    ThisType& secondaryExecId(Int64NULL value) noexcept
    {
        constexpr BlockLength offset = 174;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& secondaryExecId(NullOpt) noexcept
    {
        constexpr BlockLength offset = 174;
 
        setOrdinary(offset, NullInt64NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto linkExecId() const noexcept
    {
        constexpr BlockLength offset = 182;
 
        return ordinary<NullInt64NULL>(offset, optional);
    }

    ThisType& linkExecId(Int64NULL value) noexcept
    {
        constexpr BlockLength offset = 182;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& linkExecId(NullOpt) noexcept
    {
        constexpr BlockLength offset = 182;
 
        setOrdinary(offset, NullInt64NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto lastParPx() const noexcept
    {
        constexpr BlockLength offset = 190;
 
        return ordinary<NullDecimal9>(offset, optional);
    }

    ThisType& lastParPx(Decimal9 value) noexcept
    {
        constexpr BlockLength offset = 190;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& lastParPx(NullOpt) noexcept
    {
        constexpr BlockLength offset = 190;
 
        setOrdinary(offset, NullDecimal9());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto deliveryStartDate() const noexcept(ticksToTimestamp::Nothrow)
    {
        constexpr BlockLength offset = 198;
        return convertible<NullUTCTimestamp, ticksToTimestamp>(offset, optional);
    }

    ThisType& deliveryStartDate(Timestamp value) noexcept(timestampToTicks::Nothrow)
    {
        constexpr BlockLength offset = 198;
 
        setOrdinary(offset, convert<timestampToTicks>(value));
        return *this;
    }
 
    ThisType& deliveryStartDate(NullOpt) noexcept
    {
        constexpr BlockLength offset = 198;
 
        setOrdinary(offset, NullUTCTimestamp());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto deliveryEndDate() const noexcept(ticksToTimestamp::Nothrow)
    {
        constexpr BlockLength offset = 206;
        return convertible<NullUTCTimestamp, ticksToTimestamp>(offset, optional);
    }

    ThisType& deliveryEndDate(Timestamp value) noexcept(timestampToTicks::Nothrow)
    {
        constexpr BlockLength offset = 206;
 
        setOrdinary(offset, convert<timestampToTicks>(value));
        return *this;
    }
 
    ThisType& deliveryEndDate(NullOpt) noexcept
    {
        constexpr BlockLength offset = 206;
 
        setOrdinary(offset, NullUTCTimestamp());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto crossId() const noexcept
    {
        constexpr BlockLength offset = 214;
 
        return ordinary<NullInt64NULL>(offset, optional);
    }

    ThisType& crossId(Int64NULL value) noexcept
    {
        constexpr BlockLength offset = 214;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& crossId(NullOpt) noexcept
    {
        constexpr BlockLength offset = 214;
 
        setOrdinary(offset, NullInt64NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto crossType() const noexcept
    {
        constexpr BlockLength offset = 222;
 
        return enumeration<CrossTypeEnum, NullCharType>(offset, optional);
    }

    ThisType& crossType(CrossTypeEnum value) noexcept
    {
        constexpr BlockLength offset = 222;
 
        setEnumeration<CrossTypeEnum>(offset, value);
        return *this;
    }
 
    ThisType& crossType(NullOpt) noexcept
    {
        constexpr BlockLength offset = 222;
 
        setOrdinary(offset, NullCharType());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto waiverIndicator() const noexcept
    {
        constexpr BlockLength offset = 223;
 
        return enumeration<WaiverIndicatorEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& waiverIndicator(WaiverIndicatorEnum value) noexcept
    {
        constexpr BlockLength offset = 223;
 
        setEnumeration<WaiverIndicatorEnum>(offset, value);
        return *this;
    }
 
    ThisType& waiverIndicator(NullOpt) noexcept
    {
        constexpr BlockLength offset = 223;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto tradeType() const noexcept
    {
        constexpr BlockLength offset = 224;
        constexpr BlockLength length = 3;
 
        return fixedStr<length>(offset, optional);
    }

    ThisType& tradeType(StrRef value) noexcept
    {
        constexpr BlockLength offset = 224;
        constexpr BlockLength length = 3;
 
        setFixedStr<length>(offset, value);
        return *this;
    }
 
    ThisType& tradeType(NullOpt) noexcept
    {
        constexpr BlockLength offset = 224;
        constexpr BlockLength length = 3;
 
        setFixedStr<length>(offset, StrRef());
        return *this;
    }

    constexpr
    static BlockLength minimalBlockLength(ONIXS_ICEBOE_UNUSED SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            227;
    }

    constexpr
    static BlockLength blockLength(SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            minimalBlockLength(version);
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static MessageSize getMinimalVariableFieldsSize(ONIXS_ICEBOE_UNUSED SchemaVersion version)
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            0;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static UInt64 getMaxMessageSize(UInt8) noexcept
    {
        return
            static_cast<UInt64>(MessageHeaderBuilder::Size) +
            blockLength(Schema::Version);
    }

    ThisType& resetVariableFields() noexcept
    {
        return *this;
    }

    ThisType& reset() noexcept
    {
        origOrderId(nullOpt);
        lastPx(nullOpt);
        numOfLots(nullOpt);
        clearingFirm(nullOpt);
        clearingAccount(nullOpt);
        memo(nullOpt);
        execRefId(nullOpt);
        legExecutions(nullOpt);
        secondaryExecId(nullOpt);
        linkExecId(nullOpt);
        lastParPx(nullOpt);
        deliveryStartDate(nullOpt);
        deliveryEndDate(nullOpt);
        crossId(nullOpt);
        crossType(nullOpt);
        waiverIndicator(nullOpt);
        tradeType(nullOpt);
 
        resetVariableFields();
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef className() noexcept
    {
        return constructStrRef("ExecutionReport_Trade");
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef fixType() noexcept
    {
        return constructStrRef("8");
    }

    ONIXS_ICEBOE_NODISCARD
    std::string toString() const;

    ONIXS_ICEBOE_NODISCARD
    const void* tail() const noexcept
    {
        return
            toOpaquePtr(
                advanceByBytes(
                    binary(),
                    static_cast<ptrdiff_t>(SbeMessage::blockLength()) +
                        MessageHeader::Size));
    }

    ONIXS_ICEBOE_NODISCARD
    EncodedLength calculateBinarySize() const noexcept
    {
        return
            SbeMessage::calculateBinarySize(tail());
    }
 
private:
    void checkLength(
        EncodedLength length, SchemaVersion version) const
    {
       const EncodedLength minimalRequiredLength =
           minimalBlockLength(version) +
           MessageHeader::Size +
           getMinimalVariableFieldsSize(version);
 
       checkBinaryLength(
           *this, length, minimalRequiredLength);
    }
 
    void checkCompatibility() const
    {
        assert(TemplateId == templateId());
 
        checkSchema<Schema>(schemaId(), version());
        checkLength(bufferSize(), version());
    }
};

struct
QuoteReport
: SbeMessage
{
    typedef SchemaTraits Schema;

    typedef QuoteReport ThisType;

    enum { TemplateId = 107 };

    QuoteReport() = default;

    QuoteReport(void* data, EncodedLength length, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        reset();
    }

    QuoteReport(void* data, EncodedLength length, NoFieldsInit, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        resetVariableFields();
    }

    QuoteReport(void* data, EncodedLength length, NoInit)
      : SbeMessage(data, length)
    {
        checkCompatibility();
    }

    explicit
    QuoteReport(const SbeMessage& message)
      : SbeMessage(message)
    {
        assert(message.valid());
 
        checkCompatibility();
    }

    QuoteReport(void* data, EncodedLength length, NoInit, NoCheck) noexcept
      : SbeMessage(data, length, NoCheck())
    {
        assert(schemaId() == Schema::Id);
        assert(version() >= Schema::MinimalVersion);
        assert(TemplateId == templateId());
    }

    ONIXS_ICEBOE_NODISCARD
    auto originatorUserId() const noexcept
    {
        constexpr BlockLength offset = 0;
        constexpr BlockLength length = 20;
 
        return fixedStr<length>(offset);
    }

    ThisType& originatorUserId(StrRef value) noexcept
    {
        constexpr BlockLength offset = 0;
        constexpr BlockLength length = 20;
 
        setFixedStr<length>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto side() const noexcept
    {
        constexpr BlockLength offset = 20;
 
        return enumeration<SideEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& side(SideEnum value) noexcept
    {
        constexpr BlockLength offset = 20;
 
        setEnumeration<SideEnum>(offset, value);
        return *this;
    }
 
    ThisType& side(NullOpt) noexcept
    {
        constexpr BlockLength offset = 20;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto symbol() const noexcept
    {
        constexpr BlockLength offset = 21;
 
        return ordinary<Int32>(offset);
    }

    ThisType& symbol(Int32 value) noexcept
    {
        constexpr BlockLength offset = 21;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto rfqReqId() const noexcept
    {
        constexpr BlockLength offset = 25;
 
        return ordinary<Int64>(offset);
    }

    ThisType& rfqReqId(Int64 value) noexcept
    {
        constexpr BlockLength offset = 25;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto rfqSystemId() const noexcept
    {
        constexpr BlockLength offset = 33;
 
        return ordinary<Int64>(offset);
    }

    ThisType& rfqSystemId(Int64 value) noexcept
    {
        constexpr BlockLength offset = 33;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto transactTime() const noexcept(ticksToTimestamp::Nothrow)
    {
        constexpr BlockLength offset = 41;
        return convertible<ticksToTimestamp>(offset);
    }

    ThisType& transactTime(Timestamp value) noexcept(timestampToTicks::Nothrow)
    {
        constexpr BlockLength offset = 41;
 
        setOrdinary(offset, convert<timestampToTicks>(value));
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto orderQty() const noexcept
    {
        constexpr BlockLength offset = 49;
 
        return ordinary<NullDecimal9>(offset, optional);
    }

    ThisType& orderQty(Decimal9 value) noexcept
    {
        constexpr BlockLength offset = 49;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& orderQty(NullOpt) noexcept
    {
        constexpr BlockLength offset = 49;
 
        setOrdinary(offset, NullDecimal9());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto quoteAckStatus() const noexcept
    {
        constexpr BlockLength offset = 57;
 
        return enumeration<QuoteAckStatusEnum>(offset);
    }

    ThisType& quoteAckStatus(QuoteAckStatusEnum value) noexcept
    {
        constexpr BlockLength offset = 57;
 
        setEnumeration<QuoteAckStatusEnum>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto quoteRejectReason() const noexcept
    {
        constexpr BlockLength offset = 59;
 
        return enumeration<QuoteRejectReasonEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& quoteRejectReason(QuoteRejectReasonEnum value) noexcept
    {
        constexpr BlockLength offset = 59;
 
        setEnumeration<QuoteRejectReasonEnum>(offset, value);
        return *this;
    }
 
    ThisType& quoteRejectReason(NullOpt) noexcept
    {
        constexpr BlockLength offset = 59;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    constexpr
    static BlockLength minimalBlockLength(ONIXS_ICEBOE_UNUSED SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            60;
    }

    constexpr
    static BlockLength blockLength(SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            minimalBlockLength(version);
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static MessageSize getMinimalVariableFieldsSize(ONIXS_ICEBOE_UNUSED SchemaVersion version)
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            0;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static UInt64 getMaxMessageSize(UInt8) noexcept
    {
        return
            static_cast<UInt64>(MessageHeaderBuilder::Size) +
            blockLength(Schema::Version);
    }

    ThisType& resetVariableFields() noexcept
    {
        return *this;
    }

    ThisType& reset() noexcept
    {
        side(nullOpt);
        orderQty(nullOpt);
        quoteRejectReason(nullOpt);
 
        resetVariableFields();
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef className() noexcept
    {
        return constructStrRef("QuoteReport");
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef fixType() noexcept
    {
        return constructStrRef("QuoteReport");
    }

    ONIXS_ICEBOE_NODISCARD
    std::string toString() const;

    ONIXS_ICEBOE_NODISCARD
    const void* tail() const noexcept
    {
        return
            toOpaquePtr(
                advanceByBytes(
                    binary(),
                    static_cast<ptrdiff_t>(SbeMessage::blockLength()) +
                        MessageHeader::Size));
    }

    ONIXS_ICEBOE_NODISCARD
    EncodedLength calculateBinarySize() const noexcept
    {
        return
            SbeMessage::calculateBinarySize(tail());
    }
 
private:
    void checkLength(
        EncodedLength length, SchemaVersion version) const
    {
       const EncodedLength minimalRequiredLength =
           minimalBlockLength(version) +
           MessageHeader::Size +
           getMinimalVariableFieldsSize(version);
 
       checkBinaryLength(
           *this, length, minimalRequiredLength);
    }
 
    void checkCompatibility() const
    {
        assert(TemplateId == templateId());
 
        checkSchema<Schema>(schemaId(), version());
        checkLength(bufferSize(), version());
    }
};

struct
NewOrderCrossReport
: SbeMessage
{
    typedef SchemaTraits Schema;

    typedef NewOrderCrossReport ThisType;

    enum { TemplateId = 108 };

    NewOrderCrossReport() = default;

    NewOrderCrossReport(void* data, EncodedLength length, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        reset();
    }

    NewOrderCrossReport(void* data, EncodedLength length, NoFieldsInit, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        resetVariableFields();
    }

    NewOrderCrossReport(void* data, EncodedLength length, NoInit)
      : SbeMessage(data, length)
    {
        checkCompatibility();
    }

    explicit
    NewOrderCrossReport(const SbeMessage& message)
      : SbeMessage(message)
    {
        assert(message.valid());
 
        checkCompatibility();
    }

    NewOrderCrossReport(void* data, EncodedLength length, NoInit, NoCheck) noexcept
      : SbeMessage(data, length, NoCheck())
    {
        assert(schemaId() == Schema::Id);
        assert(version() >= Schema::MinimalVersion);
        assert(TemplateId == templateId());
    }

    ONIXS_ICEBOE_NODISCARD
    auto originatorUserId() const noexcept
    {
        constexpr BlockLength offset = 0;
        constexpr BlockLength length = 20;
 
        return fixedStr<length>(offset);
    }

    ThisType& originatorUserId(StrRef value) noexcept
    {
        constexpr BlockLength offset = 0;
        constexpr BlockLength length = 20;
 
        setFixedStr<length>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto symbol() const noexcept
    {
        constexpr BlockLength offset = 20;
 
        return ordinary<Int32>(offset);
    }

    ThisType& symbol(Int32 value) noexcept
    {
        constexpr BlockLength offset = 20;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto crossId() const noexcept
    {
        constexpr BlockLength offset = 24;
 
        return ordinary<Int64>(offset);
    }

    ThisType& crossId(Int64 value) noexcept
    {
        constexpr BlockLength offset = 24;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto transactTime() const noexcept(ticksToTimestamp::Nothrow)
    {
        constexpr BlockLength offset = 32;
        return convertible<ticksToTimestamp>(offset);
    }

    ThisType& transactTime(Timestamp value) noexcept(timestampToTicks::Nothrow)
    {
        constexpr BlockLength offset = 32;
 
        setOrdinary(offset, convert<timestampToTicks>(value));
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto rfcStatus() const noexcept
    {
        constexpr BlockLength offset = 40;
 
        return enumeration<RFCStatusEnum>(offset);
    }

    ThisType& rfcStatus(RFCStatusEnum value) noexcept
    {
        constexpr BlockLength offset = 40;
 
        setEnumeration<RFCStatusEnum>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto exchangeCode() const noexcept
    {
        constexpr BlockLength offset = 41;
 
        return ordinary<NullInt32NULL>(offset, optional);
    }

    ThisType& exchangeCode(Int32NULL value) noexcept
    {
        constexpr BlockLength offset = 41;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& exchangeCode(NullOpt) noexcept
    {
        constexpr BlockLength offset = 41;
 
        setOrdinary(offset, NullInt32NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto text() const noexcept
    {
        constexpr BlockLength offset = 45;
        constexpr BlockLength length = 100;
 
        return fixedStr<length>(offset, optional);
    }

    ThisType& text(StrRef value) noexcept
    {
        constexpr BlockLength offset = 45;
        constexpr BlockLength length = 100;
 
        setFixedStr<length>(offset, value);
        return *this;
    }
 
    ThisType& text(NullOpt) noexcept
    {
        constexpr BlockLength offset = 45;
        constexpr BlockLength length = 100;
 
        setFixedStr<length>(offset, StrRef());
        return *this;
    }

    constexpr
    static BlockLength minimalBlockLength(ONIXS_ICEBOE_UNUSED SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            145;
    }

    constexpr
    static BlockLength blockLength(SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            minimalBlockLength(version);
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static MessageSize getMinimalVariableFieldsSize(ONIXS_ICEBOE_UNUSED SchemaVersion version)
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            0;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static UInt64 getMaxMessageSize(UInt8) noexcept
    {
        return
            static_cast<UInt64>(MessageHeaderBuilder::Size) +
            blockLength(Schema::Version);
    }

    ThisType& resetVariableFields() noexcept
    {
        return *this;
    }

    ThisType& reset() noexcept
    {
        exchangeCode(nullOpt);
        text(nullOpt);
 
        resetVariableFields();
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef className() noexcept
    {
        return constructStrRef("NewOrderCrossReport");
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef fixType() noexcept
    {
        return constructStrRef("NewOrderCrossReport");
    }

    ONIXS_ICEBOE_NODISCARD
    std::string toString() const;

    ONIXS_ICEBOE_NODISCARD
    const void* tail() const noexcept
    {
        return
            toOpaquePtr(
                advanceByBytes(
                    binary(),
                    static_cast<ptrdiff_t>(SbeMessage::blockLength()) +
                        MessageHeader::Size));
    }

    ONIXS_ICEBOE_NODISCARD
    EncodedLength calculateBinarySize() const noexcept
    {
        return
            SbeMessage::calculateBinarySize(tail());
    }
 
private:
    void checkLength(
        EncodedLength length, SchemaVersion version) const
    {
       const EncodedLength minimalRequiredLength =
           minimalBlockLength(version) +
           MessageHeader::Size +
           getMinimalVariableFieldsSize(version);
 
       checkBinaryLength(
           *this, length, minimalRequiredLength);
    }
 
    void checkCompatibility() const
    {
        assert(TemplateId == templateId());
 
        checkSchema<Schema>(schemaId(), version());
        checkLength(bufferSize(), version());
    }
};

struct
OrderMassCancelReport
: SbeMessage
{
    typedef SchemaTraits Schema;

    typedef OrderMassCancelReport ThisType;

    enum { TemplateId = 109 };

    OrderMassCancelReport() = default;

    OrderMassCancelReport(void* data, EncodedLength length, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        reset();
    }

    OrderMassCancelReport(void* data, EncodedLength length, NoFieldsInit, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        resetVariableFields();
    }

    OrderMassCancelReport(void* data, EncodedLength length, NoInit)
      : SbeMessage(data, length)
    {
        checkCompatibility();
    }

    explicit
    OrderMassCancelReport(const SbeMessage& message)
      : SbeMessage(message)
    {
        assert(message.valid());
 
        checkCompatibility();
    }

    OrderMassCancelReport(void* data, EncodedLength length, NoInit, NoCheck) noexcept
      : SbeMessage(data, length, NoCheck())
    {
        assert(schemaId() == Schema::Id);
        assert(version() >= Schema::MinimalVersion);
        assert(TemplateId == templateId());
    }

    ONIXS_ICEBOE_NODISCARD
    auto originatorUserId() const noexcept
    {
        constexpr BlockLength offset = 0;
        constexpr BlockLength length = 20;
 
        return fixedStr<length>(offset);
    }

    ThisType& originatorUserId(StrRef value) noexcept
    {
        constexpr BlockLength offset = 0;
        constexpr BlockLength length = 20;
 
        setFixedStr<length>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto symbol() const noexcept
    {
        constexpr BlockLength offset = 20;
 
        return ordinary<NullInt32NULL>(offset, optional);
    }

    ThisType& symbol(Int32NULL value) noexcept
    {
        constexpr BlockLength offset = 20;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& symbol(NullOpt) noexcept
    {
        constexpr BlockLength offset = 20;
 
        setOrdinary(offset, NullInt32NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto clOrdId() const noexcept
    {
        constexpr BlockLength offset = 24;
 
        return ordinary<Int64>(offset);
    }

    ThisType& clOrdId(Int64 value) noexcept
    {
        constexpr BlockLength offset = 24;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto transactTime() const noexcept(ticksToTimestamp::Nothrow)
    {
        constexpr BlockLength offset = 32;
        return convertible<ticksToTimestamp>(offset);
    }

    ThisType& transactTime(Timestamp value) noexcept(timestampToTicks::Nothrow)
    {
        constexpr BlockLength offset = 32;
 
        setOrdinary(offset, convert<timestampToTicks>(value));
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto marketTypeId() const noexcept
    {
        constexpr BlockLength offset = 40;
 
        return ordinary<NullInt32NULL>(offset, optional);
    }

    ThisType& marketTypeId(Int32NULL value) noexcept
    {
        constexpr BlockLength offset = 40;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& marketTypeId(NullOpt) noexcept
    {
        constexpr BlockLength offset = 40;
 
        setOrdinary(offset, NullInt32NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto massCancelRequestType() const noexcept
    {
        constexpr BlockLength offset = 44;
 
        return enumeration<MassCancelRequestTypeEnum>(offset);
    }

    ThisType& massCancelRequestType(MassCancelRequestTypeEnum value) noexcept
    {
        constexpr BlockLength offset = 44;
 
        setEnumeration<MassCancelRequestTypeEnum>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto massCancelResponse() const noexcept
    {
        constexpr BlockLength offset = 45;
 
        return enumeration<MassCancelResponseEnum>(offset);
    }

    ThisType& massCancelResponse(MassCancelResponseEnum value) noexcept
    {
        constexpr BlockLength offset = 45;
 
        setEnumeration<MassCancelResponseEnum>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto massCancelRejectReason() const noexcept
    {
        constexpr BlockLength offset = 46;
 
        return enumeration<MassCancelRejectEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& massCancelRejectReason(MassCancelRejectEnum value) noexcept
    {
        constexpr BlockLength offset = 46;
 
        setEnumeration<MassCancelRejectEnum>(offset, value);
        return *this;
    }
 
    ThisType& massCancelRejectReason(NullOpt) noexcept
    {
        constexpr BlockLength offset = 46;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto exchangeCode() const noexcept
    {
        constexpr BlockLength offset = 47;
 
        return ordinary<NullInt32NULL>(offset, optional);
    }

    ThisType& exchangeCode(Int32NULL value) noexcept
    {
        constexpr BlockLength offset = 47;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& exchangeCode(NullOpt) noexcept
    {
        constexpr BlockLength offset = 47;
 
        setOrdinary(offset, NullInt32NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto text() const noexcept
    {
        constexpr BlockLength offset = 51;
        constexpr BlockLength length = 100;
 
        return fixedStr<length>(offset, optional);
    }

    ThisType& text(StrRef value) noexcept
    {
        constexpr BlockLength offset = 51;
        constexpr BlockLength length = 100;
 
        setFixedStr<length>(offset, value);
        return *this;
    }
 
    ThisType& text(NullOpt) noexcept
    {
        constexpr BlockLength offset = 51;
        constexpr BlockLength length = 100;
 
        setFixedStr<length>(offset, StrRef());
        return *this;
    }

    constexpr
    static BlockLength minimalBlockLength(ONIXS_ICEBOE_UNUSED SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            151;
    }

    constexpr
    static BlockLength blockLength(SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            minimalBlockLength(version);
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static MessageSize getMinimalVariableFieldsSize(ONIXS_ICEBOE_UNUSED SchemaVersion version)
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            0;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static UInt64 getMaxMessageSize(UInt8) noexcept
    {
        return
            static_cast<UInt64>(MessageHeaderBuilder::Size) +
            blockLength(Schema::Version);
    }

    ThisType& resetVariableFields() noexcept
    {
        return *this;
    }

    ThisType& reset() noexcept
    {
        symbol(nullOpt);
        marketTypeId(nullOpt);
        massCancelRejectReason(nullOpt);
        exchangeCode(nullOpt);
        text(nullOpt);
 
        resetVariableFields();
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef className() noexcept
    {
        return constructStrRef("OrderMassCancelReport");
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef fixType() noexcept
    {
        return constructStrRef("r");
    }

    ONIXS_ICEBOE_NODISCARD
    std::string toString() const;

    ONIXS_ICEBOE_NODISCARD
    const void* tail() const noexcept
    {
        return
            toOpaquePtr(
                advanceByBytes(
                    binary(),
                    static_cast<ptrdiff_t>(SbeMessage::blockLength()) +
                        MessageHeader::Size));
    }

    ONIXS_ICEBOE_NODISCARD
    EncodedLength calculateBinarySize() const noexcept
    {
        return
            SbeMessage::calculateBinarySize(tail());
    }
 
private:
    void checkLength(
        EncodedLength length, SchemaVersion version) const
    {
       const EncodedLength minimalRequiredLength =
           minimalBlockLength(version) +
           MessageHeader::Size +
           getMinimalVariableFieldsSize(version);
 
       checkBinaryLength(
           *this, length, minimalRequiredLength);
    }
 
    void checkCompatibility() const
    {
        assert(TemplateId == templateId());
 
        checkSchema<Schema>(schemaId(), version());
        checkLength(bufferSize(), version());
    }
};

struct
MassQuoteReport
: SbeMessage
{
    typedef SchemaTraits Schema;

    typedef MassQuoteReport ThisType;

    enum { TemplateId = 110 };

    struct
    QuoteSetsEntry : SbeGroupEntry
    <
        GroupSizeEncoding::BlockLength
    >
    {
        typedef
        SbeGroupEntry
        <
            GroupSizeEncoding::BlockLength
        >
        Base;

        typedef QuoteSetsEntry ThisType;

        QuoteSetsEntry(void* data, EncodedLength length, SchemaVersion version)
          : Base(data, numericCast<Base::BlockLength>(length), version)
        {
            assert(version >= Schema::MinimalVersion);
            assert(length >= minimalBlockLength(version));
        }

        ThisType& resetVariableFields() noexcept
        {
            return *this;
        }

        ThisType& reset() noexcept
        {
            quoteEntryRejectReason(nullOpt);
            quoteEntryExchangeCode(nullOpt);
            quoteEntryRejectReasonText(nullOpt);
 
            resetVariableFields();
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto quoteSetId() const noexcept
        {
            constexpr BlockLength offset = 0;
 
            return ordinary<Int32>(offset);
        }

        ThisType& quoteSetId(Int32 value) noexcept
        {
            constexpr BlockLength offset = 0;
 
            setOrdinary(offset, value);
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto underlyingSymbol() const noexcept
        {
            constexpr BlockLength offset = 4;
 
            return ordinary<Int32>(offset);
        }

        ThisType& underlyingSymbol(Int32 value) noexcept
        {
            constexpr BlockLength offset = 4;
 
            setOrdinary(offset, value);
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto quoteEntryId() const noexcept
        {
            constexpr BlockLength offset = 8;
 
            return ordinary<Int32>(offset);
        }

        ThisType& quoteEntryId(Int32 value) noexcept
        {
            constexpr BlockLength offset = 8;
 
            setOrdinary(offset, value);
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto symbol() const noexcept
        {
            constexpr BlockLength offset = 12;
 
            return ordinary<Int32>(offset);
        }

        ThisType& symbol(Int32 value) noexcept
        {
            constexpr BlockLength offset = 12;
 
            setOrdinary(offset, value);
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto quoteEntryRejectReason() const noexcept
        {
            constexpr BlockLength offset = 16;
 
            return enumeration<QuoteEntryRejectReasonEnum, NullUint8NULL>(offset, optional);
        }

        ThisType& quoteEntryRejectReason(QuoteEntryRejectReasonEnum value) noexcept
        {
            constexpr BlockLength offset = 16;
 
            setEnumeration<QuoteEntryRejectReasonEnum>(offset, value);
            return *this;
        }
 
        ThisType& quoteEntryRejectReason(NullOpt) noexcept
        {
            constexpr BlockLength offset = 16;
 
            setOrdinary(offset, NullUint8NULL());
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto quoteEntryExchangeCode() const noexcept
        {
            constexpr BlockLength offset = 17;
 
            return ordinary<NullInt32NULL>(offset, optional);
        }

        ThisType& quoteEntryExchangeCode(Int32NULL value) noexcept
        {
            constexpr BlockLength offset = 17;
 
            setOrdinary(offset, value);
            return *this;
        }
 
        ThisType& quoteEntryExchangeCode(NullOpt) noexcept
        {
            constexpr BlockLength offset = 17;
 
            setOrdinary(offset, NullInt32NULL());
            return *this;
        }

        ONIXS_ICEBOE_NODISCARD
        auto quoteEntryRejectReasonText() const noexcept
        {
            constexpr BlockLength offset = 21;
            constexpr BlockLength length = 100;
 
            return fixedStr<length>(offset, optional);
        }

        ThisType& quoteEntryRejectReasonText(StrRef value) noexcept
        {
            constexpr BlockLength offset = 21;
            constexpr BlockLength length = 100;
 
            setFixedStr<length>(offset, value);
            return *this;
        }
 
        ThisType& quoteEntryRejectReasonText(NullOpt) noexcept
        {
            constexpr BlockLength offset = 21;
            constexpr BlockLength length = 100;
 
            setFixedStr<length>(offset, StrRef());
            return *this;
        }

        constexpr
        static BlockLength blockLength(SchemaVersion version) noexcept
        {
            return
                ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
                minimalBlockLength(version);
        }

        constexpr
        static BlockLength minimalBlockLength(ONIXS_ICEBOE_UNUSED SchemaVersion version) noexcept
        {
            return
                ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
                121;
        }

        ONIXS_ICEBOE_NODISCARD
        constexpr
        static StrRef className() noexcept
        {
            return constructStrRef("MassQuoteReport.QuoteSetsEntry");
        }
    };

    typedef
    SbeGroup<QuoteSetsEntry, GroupSizeEncoding, MessageSize>
    QuoteSets;

    MassQuoteReport() = default;

    MassQuoteReport(void* data, EncodedLength length, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        reset();
    }

    MassQuoteReport(void* data, EncodedLength length, NoFieldsInit, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        resetVariableFields();
    }

    MassQuoteReport(void* data, EncodedLength length, NoInit)
      : SbeMessage(data, length)
    {
        checkCompatibility();
    }

    explicit
    MassQuoteReport(const SbeMessage& message)
      : SbeMessage(message)
    {
        assert(message.valid());
 
        checkCompatibility();
    }

    MassQuoteReport(void* data, EncodedLength length, NoInit, NoCheck) noexcept
      : SbeMessage(data, length, NoCheck())
    {
        assert(schemaId() == Schema::Id);
        assert(version() >= Schema::MinimalVersion);
        assert(TemplateId == templateId());
    }

    ONIXS_ICEBOE_NODISCARD
    auto quoteId() const noexcept
    {
        constexpr BlockLength offset = 0;
 
        return ordinary<Int64>(offset);
    }

    ThisType& quoteId(Int64 value) noexcept
    {
        constexpr BlockLength offset = 0;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto originatorUserId() const noexcept
    {
        constexpr BlockLength offset = 8;
        constexpr BlockLength length = 20;
 
        return fixedStr<length>(offset);
    }

    ThisType& originatorUserId(StrRef value) noexcept
    {
        constexpr BlockLength offset = 8;
        constexpr BlockLength length = 20;
 
        setFixedStr<length>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto riskProtectionReset() const noexcept
    {
        constexpr BlockLength offset = 28;
 
        return enumeration<BooleanEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& riskProtectionReset(BooleanEnum value) noexcept
    {
        constexpr BlockLength offset = 28;
 
        setEnumeration<BooleanEnum>(offset, value);
        return *this;
    }
 
    ThisType& riskProtectionReset(NullOpt) noexcept
    {
        constexpr BlockLength offset = 28;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto quoteAckStatus() const noexcept
    {
        constexpr BlockLength offset = 29;
 
        return enumeration<QuoteAckStatusEnum>(offset);
    }

    ThisType& quoteAckStatus(QuoteAckStatusEnum value) noexcept
    {
        constexpr BlockLength offset = 29;
 
        setEnumeration<QuoteAckStatusEnum>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto quoteRejectReason() const noexcept
    {
        constexpr BlockLength offset = 31;
 
        return enumeration<QuoteRejectReasonEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& quoteRejectReason(QuoteRejectReasonEnum value) noexcept
    {
        constexpr BlockLength offset = 31;
 
        setEnumeration<QuoteRejectReasonEnum>(offset, value);
        return *this;
    }
 
    ThisType& quoteRejectReason(NullOpt) noexcept
    {
        constexpr BlockLength offset = 31;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto transactTime() const noexcept(ticksToTimestamp::Nothrow)
    {
        constexpr BlockLength offset = 32;
        return convertible<NullUTCTimestamp, ticksToTimestamp>(offset, optional);
    }

    ThisType& transactTime(Timestamp value) noexcept(timestampToTicks::Nothrow)
    {
        constexpr BlockLength offset = 32;
 
        setOrdinary(offset, convert<timestampToTicks>(value));
        return *this;
    }
 
    ThisType& transactTime(NullOpt) noexcept
    {
        constexpr BlockLength offset = 32;
 
        setOrdinary(offset, NullUTCTimestamp());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto meAcceptanceTime() const noexcept(ticksToTimestamp::Nothrow)
    {
        constexpr BlockLength offset = 40;
        return convertible<NullUTCTimestamp, ticksToTimestamp>(offset, optional);
    }

    ThisType& meAcceptanceTime(Timestamp value) noexcept(timestampToTicks::Nothrow)
    {
        constexpr BlockLength offset = 40;
 
        setOrdinary(offset, convert<timestampToTicks>(value));
        return *this;
    }
 
    ThisType& meAcceptanceTime(NullOpt) noexcept
    {
        constexpr BlockLength offset = 40;
 
        setOrdinary(offset, NullUTCTimestamp());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto exchangeCode() const noexcept
    {
        constexpr BlockLength offset = 48;
 
        return ordinary<NullInt32NULL>(offset, optional);
    }

    ThisType& exchangeCode(Int32NULL value) noexcept
    {
        constexpr BlockLength offset = 48;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& exchangeCode(NullOpt) noexcept
    {
        constexpr BlockLength offset = 48;
 
        setOrdinary(offset, NullInt32NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto text() const noexcept
    {
        constexpr BlockLength offset = 52;
        constexpr BlockLength length = 100;
 
        return fixedStr<length>(offset, optional);
    }

    ThisType& text(StrRef value) noexcept
    {
        constexpr BlockLength offset = 52;
        constexpr BlockLength length = 100;
 
        setFixedStr<length>(offset, value);
        return *this;
    }
 
    ThisType& text(NullOpt) noexcept
    {
        constexpr BlockLength offset = 52;
        constexpr BlockLength length = 100;
 
        setFixedStr<length>(offset, StrRef());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    QuoteSets quoteSets() const noexcept
    {
        return getGroup<QuoteSets>(QuoteSetsAccess(), *this);
    }

    ONIXS_ICEBOE_NODISCARD
    QuoteSets quoteSets() noexcept
    {
        return getGroup<QuoteSets>(QuoteSetsAccess(), *this);
    }

    QuoteSets quoteSets(QuoteSets::Size length)
    {
        return constructGroup<QuoteSets>(
            QuoteSetsAccess(),
            length,
            *this);
    }

    QuoteSets quoteSets(QuoteSets::Size length, NoFieldsInit)
    {
        return setupGroup<QuoteSets>(
            QuoteSetsAccess(),
            length,
            *this);
    }

    constexpr
    static BlockLength minimalBlockLength(ONIXS_ICEBOE_UNUSED SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            152;
    }

    constexpr
    static BlockLength blockLength(SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            minimalBlockLength(version);
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static MessageSize getMinimalVariableFieldsSize(ONIXS_ICEBOE_UNUSED SchemaVersion version)
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            static_cast<MessageSize>(QuoteSets::EmptySize);
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static UInt64 getMaxMessageSize(UInt8 maxGroupItems = 255) noexcept
    {
        return
            static_cast<UInt64>(MessageHeaderBuilder::Size) +
            blockLength(Schema::Version) +
            (GroupSizeEncoding::Size + QuoteSetsEntry::blockLength(Schema::Version) * static_cast<UInt64>(maxGroupItems));
    }

    ThisType& resetVariableFields() noexcept
    {
        quoteSets(nullOpt);
        return *this;
    }

    ThisType& reset() noexcept
    {
        riskProtectionReset(nullOpt);
        quoteRejectReason(nullOpt);
        transactTime(nullOpt);
        meAcceptanceTime(nullOpt);
        exchangeCode(nullOpt);
        text(nullOpt);
 
        resetVariableFields();
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef className() noexcept
    {
        return constructStrRef("MassQuoteReport");
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef fixType() noexcept
    {
        return constructStrRef("b");
    }

    ONIXS_ICEBOE_NODISCARD
    std::string toString() const;

    ONIXS_ICEBOE_NODISCARD
    const void* tail() const noexcept
    {
        return
            quoteSets().tail();
    }

    ONIXS_ICEBOE_NODISCARD
    EncodedLength calculateBinarySize() const noexcept
    {
        return
            SbeMessage::calculateBinarySize(tail());
    }
 
private:
    void checkLength(
        EncodedLength length, SchemaVersion version) const
    {
       const EncodedLength minimalRequiredLength =
           minimalBlockLength(version) +
           MessageHeader::Size +
           getMinimalVariableFieldsSize(version);
 
       checkBinaryLength(
           *this, length, minimalRequiredLength);
    }

    void checkVarLenFields() const
    {
        groups().
            checkTail<QuoteSets>();
    }
 
    void checkCompatibility() const
    {
        assert(TemplateId == templateId());
 
        checkSchema<Schema>(schemaId(), version());
        checkLength(bufferSize(), version());
        checkVarLenFields();
    }

    struct QuoteSetsAccess
    {
        QuoteSets operator()(const MassQuoteReport& obj) const noexcept
        {
            return obj.
                groups().
                    head<QuoteSets>();
        }
    };

    void quoteSets(NullOpt) noexcept
    {
        resetGroup<QuoteSets>(QuoteSetsAccess(), *this);
    }
};

struct
ResendRequest
: SbeMessage
{
    typedef SchemaTraits Schema;

    typedef ResendRequest ThisType;

    enum { TemplateId = 16 };

    ResendRequest() = default;

    ResendRequest(void* data, EncodedLength length, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        reset();
    }

    ResendRequest(void* data, EncodedLength length, NoFieldsInit, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        resetVariableFields();
    }

    ResendRequest(void* data, EncodedLength length, NoInit)
      : SbeMessage(data, length)
    {
        checkCompatibility();
    }

    explicit
    ResendRequest(const SbeMessage& message)
      : SbeMessage(message)
    {
        assert(message.valid());
 
        checkCompatibility();
    }

    ResendRequest(void* data, EncodedLength length, NoInit, NoCheck) noexcept
      : SbeMessage(data, length, NoCheck())
    {
        assert(schemaId() == Schema::Id);
        assert(version() >= Schema::MinimalVersion);
        assert(TemplateId == templateId());
    }

    ONIXS_ICEBOE_NODISCARD
    auto beginSeqNo() const noexcept
    {
        constexpr BlockLength offset = 0;
 
        return ordinary<UInt32>(offset);
    }

    ThisType& beginSeqNo(UInt32 value) noexcept
    {
        constexpr BlockLength offset = 0;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto endSeqNo() const noexcept
    {
        constexpr BlockLength offset = 4;
 
        return ordinary<UInt32>(offset);
    }

    ThisType& endSeqNo(UInt32 value) noexcept
    {
        constexpr BlockLength offset = 4;
 
        setOrdinary(offset, value);
        return *this;
    }

    constexpr
    static BlockLength minimalBlockLength(ONIXS_ICEBOE_UNUSED SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            8;
    }

    constexpr
    static BlockLength blockLength(SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            minimalBlockLength(version);
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static MessageSize getMinimalVariableFieldsSize(ONIXS_ICEBOE_UNUSED SchemaVersion version)
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            0;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static UInt64 getMaxMessageSize(UInt8) noexcept
    {
        return
            static_cast<UInt64>(MessageHeaderBuilder::Size) +
            blockLength(Schema::Version);
    }

    ThisType& resetVariableFields() noexcept
    {
        return *this;
    }

    ThisType& reset() noexcept
    {
        resetVariableFields();
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef className() noexcept
    {
        return constructStrRef("ResendRequest");
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef fixType() noexcept
    {
        return constructStrRef("ResendRequest");
    }

    ONIXS_ICEBOE_NODISCARD
    std::string toString() const;

    ONIXS_ICEBOE_NODISCARD
    const void* tail() const noexcept
    {
        return
            toOpaquePtr(
                advanceByBytes(
                    binary(),
                    static_cast<ptrdiff_t>(SbeMessage::blockLength()) +
                        MessageHeader::Size));
    }

    ONIXS_ICEBOE_NODISCARD
    EncodedLength calculateBinarySize() const noexcept
    {
        return
            SbeMessage::calculateBinarySize(tail());
    }
 
private:
    void checkLength(
        EncodedLength length, SchemaVersion version) const
    {
       const EncodedLength minimalRequiredLength =
           minimalBlockLength(version) +
           MessageHeader::Size +
           getMinimalVariableFieldsSize(version);
 
       checkBinaryLength(
           *this, length, minimalRequiredLength);
    }
 
    void checkCompatibility() const
    {
        assert(TemplateId == templateId());
 
        checkSchema<Schema>(schemaId(), version());
        checkLength(bufferSize(), version());
    }
};

struct
ResendReport
: SbeMessage
{
    typedef SchemaTraits Schema;

    typedef ResendReport ThisType;

    enum { TemplateId = 117 };

    ResendReport() = default;

    ResendReport(void* data, EncodedLength length, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        reset();
    }

    ResendReport(void* data, EncodedLength length, NoFieldsInit, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        resetVariableFields();
    }

    ResendReport(void* data, EncodedLength length, NoInit)
      : SbeMessage(data, length)
    {
        checkCompatibility();
    }

    explicit
    ResendReport(const SbeMessage& message)
      : SbeMessage(message)
    {
        assert(message.valid());
 
        checkCompatibility();
    }

    ResendReport(void* data, EncodedLength length, NoInit, NoCheck) noexcept
      : SbeMessage(data, length, NoCheck())
    {
        assert(schemaId() == Schema::Id);
        assert(version() >= Schema::MinimalVersion);
        assert(TemplateId == templateId());
    }

    ONIXS_ICEBOE_NODISCARD
    auto beginSeqNo() const noexcept
    {
        constexpr BlockLength offset = 0;
 
        return ordinary<UInt32>(offset);
    }

    ThisType& beginSeqNo(UInt32 value) noexcept
    {
        constexpr BlockLength offset = 0;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto endSeqNo() const noexcept
    {
        constexpr BlockLength offset = 4;
 
        return ordinary<UInt32>(offset);
    }

    ThisType& endSeqNo(UInt32 value) noexcept
    {
        constexpr BlockLength offset = 4;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto status() const noexcept
    {
        constexpr BlockLength offset = 8;
 
        return enumeration<RequestStatusEnum>(offset);
    }

    ThisType& status(RequestStatusEnum value) noexcept
    {
        constexpr BlockLength offset = 8;
 
        setEnumeration<RequestStatusEnum>(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto exchangeCode() const noexcept
    {
        constexpr BlockLength offset = 9;
 
        return ordinary<NullInt32NULL>(offset, optional);
    }

    ThisType& exchangeCode(Int32NULL value) noexcept
    {
        constexpr BlockLength offset = 9;
 
        setOrdinary(offset, value);
        return *this;
    }
 
    ThisType& exchangeCode(NullOpt) noexcept
    {
        constexpr BlockLength offset = 9;
 
        setOrdinary(offset, NullInt32NULL());
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto text() const noexcept
    {
        constexpr BlockLength offset = 13;
        constexpr BlockLength length = 100;
 
        return fixedStr<length>(offset, optional);
    }

    ThisType& text(StrRef value) noexcept
    {
        constexpr BlockLength offset = 13;
        constexpr BlockLength length = 100;
 
        setFixedStr<length>(offset, value);
        return *this;
    }
 
    ThisType& text(NullOpt) noexcept
    {
        constexpr BlockLength offset = 13;
        constexpr BlockLength length = 100;
 
        setFixedStr<length>(offset, StrRef());
        return *this;
    }

    constexpr
    static BlockLength minimalBlockLength(ONIXS_ICEBOE_UNUSED SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            113;
    }

    constexpr
    static BlockLength blockLength(SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            minimalBlockLength(version);
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static MessageSize getMinimalVariableFieldsSize(ONIXS_ICEBOE_UNUSED SchemaVersion version)
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            0;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static UInt64 getMaxMessageSize(UInt8) noexcept
    {
        return
            static_cast<UInt64>(MessageHeaderBuilder::Size) +
            blockLength(Schema::Version);
    }

    ThisType& resetVariableFields() noexcept
    {
        return *this;
    }

    ThisType& reset() noexcept
    {
        exchangeCode(nullOpt);
        text(nullOpt);
 
        resetVariableFields();
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef className() noexcept
    {
        return constructStrRef("ResendReport");
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef fixType() noexcept
    {
        return constructStrRef("ResendReport");
    }

    ONIXS_ICEBOE_NODISCARD
    std::string toString() const;

    ONIXS_ICEBOE_NODISCARD
    const void* tail() const noexcept
    {
        return
            toOpaquePtr(
                advanceByBytes(
                    binary(),
                    static_cast<ptrdiff_t>(SbeMessage::blockLength()) +
                        MessageHeader::Size));
    }

    ONIXS_ICEBOE_NODISCARD
    EncodedLength calculateBinarySize() const noexcept
    {
        return
            SbeMessage::calculateBinarySize(tail());
    }
 
private:
    void checkLength(
        EncodedLength length, SchemaVersion version) const
    {
       const EncodedLength minimalRequiredLength =
           minimalBlockLength(version) +
           MessageHeader::Size +
           getMinimalVariableFieldsSize(version);
 
       checkBinaryLength(
           *this, length, minimalRequiredLength);
    }
 
    void checkCompatibility() const
    {
        assert(TemplateId == templateId());
 
        checkSchema<Schema>(schemaId(), version());
        checkLength(bufferSize(), version());
    }
};

struct
SequenceReset
: SbeMessage
{
    typedef SchemaTraits Schema;

    typedef SequenceReset ThisType;

    enum { TemplateId = 111 };

    SequenceReset() = default;

    SequenceReset(void* data, EncodedLength length, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        reset();
    }

    SequenceReset(void* data, EncodedLength length, NoFieldsInit, SchemaVersion version = Schema::Version)
      : SbeMessage(data, length, version)
    {
        checkVersion<Schema>(version);
        checkLength(length, version);
        init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
        resetVariableFields();
    }

    SequenceReset(void* data, EncodedLength length, NoInit)
      : SbeMessage(data, length)
    {
        checkCompatibility();
    }

    explicit
    SequenceReset(const SbeMessage& message)
      : SbeMessage(message)
    {
        assert(message.valid());
 
        checkCompatibility();
    }

    SequenceReset(void* data, EncodedLength length, NoInit, NoCheck) noexcept
      : SbeMessage(data, length, NoCheck())
    {
        assert(schemaId() == Schema::Id);
        assert(version() >= Schema::MinimalVersion);
        assert(TemplateId == templateId());
    }

    ONIXS_ICEBOE_NODISCARD
    auto newSeqNo() const noexcept
    {
        constexpr BlockLength offset = 0;
 
        return ordinary<UInt32>(offset);
    }

    ThisType& newSeqNo(UInt32 value) noexcept
    {
        constexpr BlockLength offset = 0;
 
        setOrdinary(offset, value);
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    auto gapFillFlag() const noexcept
    {
        constexpr BlockLength offset = 4;
 
        return enumeration<BooleanEnum, NullUint8NULL>(offset, optional);
    }

    ThisType& gapFillFlag(BooleanEnum value) noexcept
    {
        constexpr BlockLength offset = 4;
 
        setEnumeration<BooleanEnum>(offset, value);
        return *this;
    }
 
    ThisType& gapFillFlag(NullOpt) noexcept
    {
        constexpr BlockLength offset = 4;
 
        setOrdinary(offset, NullUint8NULL());
        return *this;
    }

    constexpr
    static BlockLength minimalBlockLength(ONIXS_ICEBOE_UNUSED SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            5;
    }

    constexpr
    static BlockLength blockLength(SchemaVersion version) noexcept
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            minimalBlockLength(version);
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static MessageSize getMinimalVariableFieldsSize(ONIXS_ICEBOE_UNUSED SchemaVersion version)
    {
        return
            ONIXS_ICEBOE_ASSERT(version >= Schema::MinimalVersion),
            0;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static UInt64 getMaxMessageSize(UInt8) noexcept
    {
        return
            static_cast<UInt64>(MessageHeaderBuilder::Size) +
            blockLength(Schema::Version);
    }

    ThisType& resetVariableFields() noexcept
    {
        return *this;
    }

    ThisType& reset() noexcept
    {
        gapFillFlag(nullOpt);
 
        resetVariableFields();
        return *this;
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef className() noexcept
    {
        return constructStrRef("SequenceReset");
    }

    ONIXS_ICEBOE_NODISCARD
    constexpr
    static StrRef fixType() noexcept
    {
        return constructStrRef("SequenceReset");
    }

    ONIXS_ICEBOE_NODISCARD
    std::string toString() const;

    ONIXS_ICEBOE_NODISCARD
    const void* tail() const noexcept
    {
        return
            toOpaquePtr(
                advanceByBytes(
                    binary(),
                    static_cast<ptrdiff_t>(SbeMessage::blockLength()) +
                        MessageHeader::Size));
    }

    ONIXS_ICEBOE_NODISCARD
    EncodedLength calculateBinarySize() const noexcept
    {
        return
            SbeMessage::calculateBinarySize(tail());
    }
 
private:
    void checkLength(
        EncodedLength length, SchemaVersion version) const
    {
       const EncodedLength minimalRequiredLength =
           minimalBlockLength(version) +
           MessageHeader::Size +
           getMinimalVariableFieldsSize(version);
 
       checkBinaryLength(
           *this, length, minimalRequiredLength);
    }
 
    void checkCompatibility() const
    {
        assert(TemplateId == templateId());
 
        checkSchema<Schema>(schemaId(), version());
        checkLength(bufferSize(), version());
    }
};
 
 
ONIXS_ICEBOE_MESSAGING_NAMESPACE_END