// Generated by Cap'n Proto compiler, DO NOT EDIT
// source: MinHash.capnp

#pragma once

#include <capnp/generated-header-support.h>
#include <kj/windows-sanity.h>

#ifndef CAPNP_VERSION
#error "CAPNP_VERSION is not defined, is capnp/generated-header-support.h missing?"
#elif CAPNP_VERSION != 1000002
#error "Version mismatch between generated code and library headers.  You must use the same version of the Cap'n Proto compiler and library."
#endif


CAPNP_BEGIN_HEADER

namespace capnp {
namespace schemas {

CAPNP_DECLARE_SCHEMA(d9d16806af782606);
CAPNP_DECLARE_SCHEMA(cf71219d02db7ad0);
CAPNP_DECLARE_SCHEMA(96c3ea4cbfe143bf);
CAPNP_DECLARE_SCHEMA(e1ddf186e2b359dd);
CAPNP_DECLARE_SCHEMA(a648d7188f2259f6);

}  // namespace schemas
}  // namespace capnp

namespace capnp {

struct MinHash {
  MinHash() = delete;

  class Reader;
  class Builder;
  class Pipeline;
  struct ReferenceList;
  struct LocusList;

  struct _capnpPrivate {
    CAPNP_DECLARE_STRUCT_HEADER(d9d16806af782606, 3, 4)
    #if !CAPNP_LITE
    static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }
    #endif  // !CAPNP_LITE
  };
};

struct MinHash::ReferenceList {
  ReferenceList() = delete;

  class Reader;
  class Builder;
  class Pipeline;
  struct Reference;

  struct _capnpPrivate {
    CAPNP_DECLARE_STRUCT_HEADER(cf71219d02db7ad0, 0, 1)
    #if !CAPNP_LITE
    static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }
    #endif  // !CAPNP_LITE
  };
};

struct MinHash::ReferenceList::Reference {
  Reference() = delete;

  class Reader;
  class Builder;
  class Pipeline;

  struct _capnpPrivate {
    CAPNP_DECLARE_STRUCT_HEADER(96c3ea4cbfe143bf, 2, 7)
    #if !CAPNP_LITE
    static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }
    #endif  // !CAPNP_LITE
  };
};

struct MinHash::LocusList {
  LocusList() = delete;

  class Reader;
  class Builder;
  class Pipeline;
  struct Locus;

  struct _capnpPrivate {
    CAPNP_DECLARE_STRUCT_HEADER(e1ddf186e2b359dd, 0, 1)
    #if !CAPNP_LITE
    static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }
    #endif  // !CAPNP_LITE
  };
};

struct MinHash::LocusList::Locus {
  Locus() = delete;

  class Reader;
  class Builder;
  class Pipeline;

  struct _capnpPrivate {
    CAPNP_DECLARE_STRUCT_HEADER(a648d7188f2259f6, 3, 0)
    #if !CAPNP_LITE
    static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }
    #endif  // !CAPNP_LITE
  };
};

// =======================================================================================

class MinHash::Reader {
public:
  typedef MinHash Reads;

  Reader() = default;
  inline explicit Reader(::capnp::_::StructReader base): _reader(base) {}

  inline ::capnp::MessageSize totalSize() const {
    return _reader.totalSize().asPublic();
  }

#if !CAPNP_LITE
  inline ::kj::StringTree toString() const {
    return ::capnp::_::structString(_reader, *_capnpPrivate::brand());
  }
#endif  // !CAPNP_LITE

  inline  ::uint32_t getKmerSize() const;

  inline  ::uint32_t getWindowSize() const;

  inline  ::uint32_t getMinHashesPerWindow() const;

  inline bool getConcatenated() const;

  inline bool hasReferenceListOld() const;
  inline  ::capnp::MinHash::ReferenceList::Reader getReferenceListOld() const;

  inline bool hasLocusList() const;
  inline  ::capnp::MinHash::LocusList::Reader getLocusList() const;

  inline float getError() const;

  inline bool getNoncanonical() const;

  inline bool hasAlphabet() const;
  inline  ::capnp::Text::Reader getAlphabet() const;

  inline bool getPreserveCase() const;

  inline  ::uint32_t getHashSeed() const;

  inline bool hasReferenceList() const;
  inline  ::capnp::MinHash::ReferenceList::Reader getReferenceList() const;

private:
  ::capnp::_::StructReader _reader;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::List;
  friend class ::capnp::MessageBuilder;
  friend class ::capnp::Orphanage;
};

class MinHash::Builder {
public:
  typedef MinHash Builds;

  Builder() = delete;  // Deleted to discourage incorrect usage.
                       // You can explicitly initialize to nullptr instead.
  inline Builder(decltype(nullptr)) {}
  inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {}
  inline operator Reader() const { return Reader(_builder.asReader()); }
  inline Reader asReader() const { return *this; }

  inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); }
#if !CAPNP_LITE
  inline ::kj::StringTree toString() const { return asReader().toString(); }
#endif  // !CAPNP_LITE

  inline  ::uint32_t getKmerSize();
  inline void setKmerSize( ::uint32_t value);

  inline  ::uint32_t getWindowSize();
  inline void setWindowSize( ::uint32_t value);

  inline  ::uint32_t getMinHashesPerWindow();
  inline void setMinHashesPerWindow( ::uint32_t value);

  inline bool getConcatenated();
  inline void setConcatenated(bool value);

  inline bool hasReferenceListOld();
  inline  ::capnp::MinHash::ReferenceList::Builder getReferenceListOld();
  inline void setReferenceListOld( ::capnp::MinHash::ReferenceList::Reader value);
  inline  ::capnp::MinHash::ReferenceList::Builder initReferenceListOld();
  inline void adoptReferenceListOld(::capnp::Orphan< ::capnp::MinHash::ReferenceList>&& value);
  inline ::capnp::Orphan< ::capnp::MinHash::ReferenceList> disownReferenceListOld();

  inline bool hasLocusList();
  inline  ::capnp::MinHash::LocusList::Builder getLocusList();
  inline void setLocusList( ::capnp::MinHash::LocusList::Reader value);
  inline  ::capnp::MinHash::LocusList::Builder initLocusList();
  inline void adoptLocusList(::capnp::Orphan< ::capnp::MinHash::LocusList>&& value);
  inline ::capnp::Orphan< ::capnp::MinHash::LocusList> disownLocusList();

  inline float getError();
  inline void setError(float value);

  inline bool getNoncanonical();
  inline void setNoncanonical(bool value);

  inline bool hasAlphabet();
  inline  ::capnp::Text::Builder getAlphabet();
  inline void setAlphabet( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initAlphabet(unsigned int size);
  inline void adoptAlphabet(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownAlphabet();

  inline bool getPreserveCase();
  inline void setPreserveCase(bool value);

  inline  ::uint32_t getHashSeed();
  inline void setHashSeed( ::uint32_t value);

  inline bool hasReferenceList();
  inline  ::capnp::MinHash::ReferenceList::Builder getReferenceList();
  inline void setReferenceList( ::capnp::MinHash::ReferenceList::Reader value);
  inline  ::capnp::MinHash::ReferenceList::Builder initReferenceList();
  inline void adoptReferenceList(::capnp::Orphan< ::capnp::MinHash::ReferenceList>&& value);
  inline ::capnp::Orphan< ::capnp::MinHash::ReferenceList> disownReferenceList();

private:
  ::capnp::_::StructBuilder _builder;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  friend class ::capnp::Orphanage;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
};

#if !CAPNP_LITE
class MinHash::Pipeline {
public:
  typedef MinHash Pipelines;

  inline Pipeline(decltype(nullptr)): _typeless(nullptr) {}
  inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless)
      : _typeless(kj::mv(typeless)) {}

  inline  ::capnp::MinHash::ReferenceList::Pipeline getReferenceListOld();
  inline  ::capnp::MinHash::LocusList::Pipeline getLocusList();
  inline  ::capnp::MinHash::ReferenceList::Pipeline getReferenceList();
private:
  ::capnp::AnyPointer::Pipeline _typeless;
  friend class ::capnp::PipelineHook;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
};
#endif  // !CAPNP_LITE

class MinHash::ReferenceList::Reader {
public:
  typedef ReferenceList Reads;

  Reader() = default;
  inline explicit Reader(::capnp::_::StructReader base): _reader(base) {}

  inline ::capnp::MessageSize totalSize() const {
    return _reader.totalSize().asPublic();
  }

#if !CAPNP_LITE
  inline ::kj::StringTree toString() const {
    return ::capnp::_::structString(_reader, *_capnpPrivate::brand());
  }
#endif  // !CAPNP_LITE

  inline bool hasReferences() const;
  inline  ::capnp::List< ::capnp::MinHash::ReferenceList::Reference,  ::capnp::Kind::STRUCT>::Reader getReferences() const;

private:
  ::capnp::_::StructReader _reader;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::List;
  friend class ::capnp::MessageBuilder;
  friend class ::capnp::Orphanage;
};

class MinHash::ReferenceList::Builder {
public:
  typedef ReferenceList Builds;

  Builder() = delete;  // Deleted to discourage incorrect usage.
                       // You can explicitly initialize to nullptr instead.
  inline Builder(decltype(nullptr)) {}
  inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {}
  inline operator Reader() const { return Reader(_builder.asReader()); }
  inline Reader asReader() const { return *this; }

  inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); }
#if !CAPNP_LITE
  inline ::kj::StringTree toString() const { return asReader().toString(); }
#endif  // !CAPNP_LITE

  inline bool hasReferences();
  inline  ::capnp::List< ::capnp::MinHash::ReferenceList::Reference,  ::capnp::Kind::STRUCT>::Builder getReferences();
  inline void setReferences( ::capnp::List< ::capnp::MinHash::ReferenceList::Reference,  ::capnp::Kind::STRUCT>::Reader value);
  inline  ::capnp::List< ::capnp::MinHash::ReferenceList::Reference,  ::capnp::Kind::STRUCT>::Builder initReferences(unsigned int size);
  inline void adoptReferences(::capnp::Orphan< ::capnp::List< ::capnp::MinHash::ReferenceList::Reference,  ::capnp::Kind::STRUCT>>&& value);
  inline ::capnp::Orphan< ::capnp::List< ::capnp::MinHash::ReferenceList::Reference,  ::capnp::Kind::STRUCT>> disownReferences();

private:
  ::capnp::_::StructBuilder _builder;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  friend class ::capnp::Orphanage;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
};

#if !CAPNP_LITE
class MinHash::ReferenceList::Pipeline {
public:
  typedef ReferenceList Pipelines;

  inline Pipeline(decltype(nullptr)): _typeless(nullptr) {}
  inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless)
      : _typeless(kj::mv(typeless)) {}

private:
  ::capnp::AnyPointer::Pipeline _typeless;
  friend class ::capnp::PipelineHook;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
};
#endif  // !CAPNP_LITE

class MinHash::ReferenceList::Reference::Reader {
public:
  typedef Reference Reads;

  Reader() = default;
  inline explicit Reader(::capnp::_::StructReader base): _reader(base) {}

  inline ::capnp::MessageSize totalSize() const {
    return _reader.totalSize().asPublic();
  }

#if !CAPNP_LITE
  inline ::kj::StringTree toString() const {
    return ::capnp::_::structString(_reader, *_capnpPrivate::brand());
  }
#endif  // !CAPNP_LITE

  inline bool hasSequence() const;
  inline  ::capnp::Text::Reader getSequence() const;

  inline bool hasQuality() const;
  inline  ::capnp::Text::Reader getQuality() const;

  inline  ::uint32_t getLength() const;

  inline bool hasName() const;
  inline  ::capnp::Text::Reader getName() const;

  inline bool hasComment() const;
  inline  ::capnp::Text::Reader getComment() const;

  inline bool hasHashes32() const;
  inline  ::capnp::List< ::uint32_t,  ::capnp::Kind::PRIMITIVE>::Reader getHashes32() const;

  inline bool hasHashes64() const;
  inline  ::capnp::List< ::uint64_t,  ::capnp::Kind::PRIMITIVE>::Reader getHashes64() const;

  inline  ::uint64_t getLength64() const;

  inline bool hasCounts32() const;
  inline  ::capnp::List< ::uint32_t,  ::capnp::Kind::PRIMITIVE>::Reader getCounts32() const;

private:
  ::capnp::_::StructReader _reader;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::List;
  friend class ::capnp::MessageBuilder;
  friend class ::capnp::Orphanage;
};

class MinHash::ReferenceList::Reference::Builder {
public:
  typedef Reference Builds;

  Builder() = delete;  // Deleted to discourage incorrect usage.
                       // You can explicitly initialize to nullptr instead.
  inline Builder(decltype(nullptr)) {}
  inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {}
  inline operator Reader() const { return Reader(_builder.asReader()); }
  inline Reader asReader() const { return *this; }

  inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); }
#if !CAPNP_LITE
  inline ::kj::StringTree toString() const { return asReader().toString(); }
#endif  // !CAPNP_LITE

  inline bool hasSequence();
  inline  ::capnp::Text::Builder getSequence();
  inline void setSequence( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initSequence(unsigned int size);
  inline void adoptSequence(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownSequence();

  inline bool hasQuality();
  inline  ::capnp::Text::Builder getQuality();
  inline void setQuality( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initQuality(unsigned int size);
  inline void adoptQuality(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownQuality();

  inline  ::uint32_t getLength();
  inline void setLength( ::uint32_t value);

  inline bool hasName();
  inline  ::capnp::Text::Builder getName();
  inline void setName( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initName(unsigned int size);
  inline void adoptName(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownName();

  inline bool hasComment();
  inline  ::capnp::Text::Builder getComment();
  inline void setComment( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initComment(unsigned int size);
  inline void adoptComment(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownComment();

  inline bool hasHashes32();
  inline  ::capnp::List< ::uint32_t,  ::capnp::Kind::PRIMITIVE>::Builder getHashes32();
  inline void setHashes32( ::capnp::List< ::uint32_t,  ::capnp::Kind::PRIMITIVE>::Reader value);
  inline void setHashes32(::kj::ArrayPtr<const  ::uint32_t> value);
  inline  ::capnp::List< ::uint32_t,  ::capnp::Kind::PRIMITIVE>::Builder initHashes32(unsigned int size);
  inline void adoptHashes32(::capnp::Orphan< ::capnp::List< ::uint32_t,  ::capnp::Kind::PRIMITIVE>>&& value);
  inline ::capnp::Orphan< ::capnp::List< ::uint32_t,  ::capnp::Kind::PRIMITIVE>> disownHashes32();

  inline bool hasHashes64();
  inline  ::capnp::List< ::uint64_t,  ::capnp::Kind::PRIMITIVE>::Builder getHashes64();
  inline void setHashes64( ::capnp::List< ::uint64_t,  ::capnp::Kind::PRIMITIVE>::Reader value);
  inline void setHashes64(::kj::ArrayPtr<const  ::uint64_t> value);
  inline  ::capnp::List< ::uint64_t,  ::capnp::Kind::PRIMITIVE>::Builder initHashes64(unsigned int size);
  inline void adoptHashes64(::capnp::Orphan< ::capnp::List< ::uint64_t,  ::capnp::Kind::PRIMITIVE>>&& value);
  inline ::capnp::Orphan< ::capnp::List< ::uint64_t,  ::capnp::Kind::PRIMITIVE>> disownHashes64();

  inline  ::uint64_t getLength64();
  inline void setLength64( ::uint64_t value);

  inline bool hasCounts32();
  inline  ::capnp::List< ::uint32_t,  ::capnp::Kind::PRIMITIVE>::Builder getCounts32();
  inline void setCounts32( ::capnp::List< ::uint32_t,  ::capnp::Kind::PRIMITIVE>::Reader value);
  inline void setCounts32(::kj::ArrayPtr<const  ::uint32_t> value);
  inline  ::capnp::List< ::uint32_t,  ::capnp::Kind::PRIMITIVE>::Builder initCounts32(unsigned int size);
  inline void adoptCounts32(::capnp::Orphan< ::capnp::List< ::uint32_t,  ::capnp::Kind::PRIMITIVE>>&& value);
  inline ::capnp::Orphan< ::capnp::List< ::uint32_t,  ::capnp::Kind::PRIMITIVE>> disownCounts32();

private:
  ::capnp::_::StructBuilder _builder;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  friend class ::capnp::Orphanage;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
};

#if !CAPNP_LITE
class MinHash::ReferenceList::Reference::Pipeline {
public:
  typedef Reference Pipelines;

  inline Pipeline(decltype(nullptr)): _typeless(nullptr) {}
  inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless)
      : _typeless(kj::mv(typeless)) {}

private:
  ::capnp::AnyPointer::Pipeline _typeless;
  friend class ::capnp::PipelineHook;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
};
#endif  // !CAPNP_LITE

class MinHash::LocusList::Reader {
public:
  typedef LocusList Reads;

  Reader() = default;
  inline explicit Reader(::capnp::_::StructReader base): _reader(base) {}

  inline ::capnp::MessageSize totalSize() const {
    return _reader.totalSize().asPublic();
  }

#if !CAPNP_LITE
  inline ::kj::StringTree toString() const {
    return ::capnp::_::structString(_reader, *_capnpPrivate::brand());
  }
#endif  // !CAPNP_LITE

  inline bool hasLoci() const;
  inline  ::capnp::List< ::capnp::MinHash::LocusList::Locus,  ::capnp::Kind::STRUCT>::Reader getLoci() const;

private:
  ::capnp::_::StructReader _reader;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::List;
  friend class ::capnp::MessageBuilder;
  friend class ::capnp::Orphanage;
};

class MinHash::LocusList::Builder {
public:
  typedef LocusList Builds;

  Builder() = delete;  // Deleted to discourage incorrect usage.
                       // You can explicitly initialize to nullptr instead.
  inline Builder(decltype(nullptr)) {}
  inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {}
  inline operator Reader() const { return Reader(_builder.asReader()); }
  inline Reader asReader() const { return *this; }

  inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); }
#if !CAPNP_LITE
  inline ::kj::StringTree toString() const { return asReader().toString(); }
#endif  // !CAPNP_LITE

  inline bool hasLoci();
  inline  ::capnp::List< ::capnp::MinHash::LocusList::Locus,  ::capnp::Kind::STRUCT>::Builder getLoci();
  inline void setLoci( ::capnp::List< ::capnp::MinHash::LocusList::Locus,  ::capnp::Kind::STRUCT>::Reader value);
  inline  ::capnp::List< ::capnp::MinHash::LocusList::Locus,  ::capnp::Kind::STRUCT>::Builder initLoci(unsigned int size);
  inline void adoptLoci(::capnp::Orphan< ::capnp::List< ::capnp::MinHash::LocusList::Locus,  ::capnp::Kind::STRUCT>>&& value);
  inline ::capnp::Orphan< ::capnp::List< ::capnp::MinHash::LocusList::Locus,  ::capnp::Kind::STRUCT>> disownLoci();

private:
  ::capnp::_::StructBuilder _builder;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  friend class ::capnp::Orphanage;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
};

#if !CAPNP_LITE
class MinHash::LocusList::Pipeline {
public:
  typedef LocusList Pipelines;

  inline Pipeline(decltype(nullptr)): _typeless(nullptr) {}
  inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless)
      : _typeless(kj::mv(typeless)) {}

private:
  ::capnp::AnyPointer::Pipeline _typeless;
  friend class ::capnp::PipelineHook;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
};
#endif  // !CAPNP_LITE

class MinHash::LocusList::Locus::Reader {
public:
  typedef Locus Reads;

  Reader() = default;
  inline explicit Reader(::capnp::_::StructReader base): _reader(base) {}

  inline ::capnp::MessageSize totalSize() const {
    return _reader.totalSize().asPublic();
  }

#if !CAPNP_LITE
  inline ::kj::StringTree toString() const {
    return ::capnp::_::structString(_reader, *_capnpPrivate::brand());
  }
#endif  // !CAPNP_LITE

  inline  ::uint32_t getSequence() const;

  inline  ::uint32_t getPosition() const;

  inline  ::uint32_t getHash32() const;

  inline  ::uint64_t getHash64() const;

private:
  ::capnp::_::StructReader _reader;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::List;
  friend class ::capnp::MessageBuilder;
  friend class ::capnp::Orphanage;
};

class MinHash::LocusList::Locus::Builder {
public:
  typedef Locus Builds;

  Builder() = delete;  // Deleted to discourage incorrect usage.
                       // You can explicitly initialize to nullptr instead.
  inline Builder(decltype(nullptr)) {}
  inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {}
  inline operator Reader() const { return Reader(_builder.asReader()); }
  inline Reader asReader() const { return *this; }

  inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); }
#if !CAPNP_LITE
  inline ::kj::StringTree toString() const { return asReader().toString(); }
#endif  // !CAPNP_LITE

  inline  ::uint32_t getSequence();
  inline void setSequence( ::uint32_t value);

  inline  ::uint32_t getPosition();
  inline void setPosition( ::uint32_t value);

  inline  ::uint32_t getHash32();
  inline void setHash32( ::uint32_t value);

  inline  ::uint64_t getHash64();
  inline void setHash64( ::uint64_t value);

private:
  ::capnp::_::StructBuilder _builder;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  friend class ::capnp::Orphanage;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
};

#if !CAPNP_LITE
class MinHash::LocusList::Locus::Pipeline {
public:
  typedef Locus Pipelines;

  inline Pipeline(decltype(nullptr)): _typeless(nullptr) {}
  inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless)
      : _typeless(kj::mv(typeless)) {}

private:
  ::capnp::AnyPointer::Pipeline _typeless;
  friend class ::capnp::PipelineHook;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
};
#endif  // !CAPNP_LITE

// =======================================================================================

inline  ::uint32_t MinHash::Reader::getKmerSize() const {
  return _reader.getDataField< ::uint32_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline  ::uint32_t MinHash::Builder::getKmerSize() {
  return _builder.getDataField< ::uint32_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void MinHash::Builder::setKmerSize( ::uint32_t value) {
  _builder.setDataField< ::uint32_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline  ::uint32_t MinHash::Reader::getWindowSize() const {
  return _reader.getDataField< ::uint32_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline  ::uint32_t MinHash::Builder::getWindowSize() {
  return _builder.getDataField< ::uint32_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void MinHash::Builder::setWindowSize( ::uint32_t value) {
  _builder.setDataField< ::uint32_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline  ::uint32_t MinHash::Reader::getMinHashesPerWindow() const {
  return _reader.getDataField< ::uint32_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline  ::uint32_t MinHash::Builder::getMinHashesPerWindow() {
  return _builder.getDataField< ::uint32_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void MinHash::Builder::setMinHashesPerWindow( ::uint32_t value) {
  _builder.setDataField< ::uint32_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline bool MinHash::Reader::getConcatenated() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<96>() * ::capnp::ELEMENTS);
}

inline bool MinHash::Builder::getConcatenated() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<96>() * ::capnp::ELEMENTS);
}
inline void MinHash::Builder::setConcatenated(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<96>() * ::capnp::ELEMENTS, value);
}

inline bool MinHash::Reader::hasReferenceListOld() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool MinHash::Builder::hasReferenceListOld() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::MinHash::ReferenceList::Reader MinHash::Reader::getReferenceListOld() const {
  return ::capnp::_::PointerHelpers< ::capnp::MinHash::ReferenceList>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::capnp::MinHash::ReferenceList::Builder MinHash::Builder::getReferenceListOld() {
  return ::capnp::_::PointerHelpers< ::capnp::MinHash::ReferenceList>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
#if !CAPNP_LITE
inline  ::capnp::MinHash::ReferenceList::Pipeline MinHash::Pipeline::getReferenceListOld() {
  return  ::capnp::MinHash::ReferenceList::Pipeline(_typeless.getPointerField(0));
}
#endif  // !CAPNP_LITE
inline void MinHash::Builder::setReferenceListOld( ::capnp::MinHash::ReferenceList::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::MinHash::ReferenceList>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::capnp::MinHash::ReferenceList::Builder MinHash::Builder::initReferenceListOld() {
  return ::capnp::_::PointerHelpers< ::capnp::MinHash::ReferenceList>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void MinHash::Builder::adoptReferenceListOld(
    ::capnp::Orphan< ::capnp::MinHash::ReferenceList>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::MinHash::ReferenceList>::adopt(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::MinHash::ReferenceList> MinHash::Builder::disownReferenceListOld() {
  return ::capnp::_::PointerHelpers< ::capnp::MinHash::ReferenceList>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline bool MinHash::Reader::hasLocusList() const {
  return !_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline bool MinHash::Builder::hasLocusList() {
  return !_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::MinHash::LocusList::Reader MinHash::Reader::getLocusList() const {
  return ::capnp::_::PointerHelpers< ::capnp::MinHash::LocusList>::get(_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline  ::capnp::MinHash::LocusList::Builder MinHash::Builder::getLocusList() {
  return ::capnp::_::PointerHelpers< ::capnp::MinHash::LocusList>::get(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
#if !CAPNP_LITE
inline  ::capnp::MinHash::LocusList::Pipeline MinHash::Pipeline::getLocusList() {
  return  ::capnp::MinHash::LocusList::Pipeline(_typeless.getPointerField(1));
}
#endif  // !CAPNP_LITE
inline void MinHash::Builder::setLocusList( ::capnp::MinHash::LocusList::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::MinHash::LocusList>::set(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), value);
}
inline  ::capnp::MinHash::LocusList::Builder MinHash::Builder::initLocusList() {
  return ::capnp::_::PointerHelpers< ::capnp::MinHash::LocusList>::init(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline void MinHash::Builder::adoptLocusList(
    ::capnp::Orphan< ::capnp::MinHash::LocusList>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::MinHash::LocusList>::adopt(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::MinHash::LocusList> MinHash::Builder::disownLocusList() {
  return ::capnp::_::PointerHelpers< ::capnp::MinHash::LocusList>::disown(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}

inline float MinHash::Reader::getError() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}

inline float MinHash::Builder::getError() {
  return _builder.getDataField<float>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}
inline void MinHash::Builder::setError(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS, value);
}

inline bool MinHash::Reader::getNoncanonical() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<97>() * ::capnp::ELEMENTS);
}

inline bool MinHash::Builder::getNoncanonical() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<97>() * ::capnp::ELEMENTS);
}
inline void MinHash::Builder::setNoncanonical(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<97>() * ::capnp::ELEMENTS, value);
}

inline bool MinHash::Reader::hasAlphabet() const {
  return !_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline bool MinHash::Builder::hasAlphabet() {
  return !_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader MinHash::Reader::getAlphabet() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder MinHash::Builder::getAlphabet() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline void MinHash::Builder::setAlphabet( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder MinHash::Builder::initAlphabet(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), size);
}
inline void MinHash::Builder::adoptAlphabet(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> MinHash::Builder::disownAlphabet() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}

inline bool MinHash::Reader::getPreserveCase() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<98>() * ::capnp::ELEMENTS);
}

inline bool MinHash::Builder::getPreserveCase() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<98>() * ::capnp::ELEMENTS);
}
inline void MinHash::Builder::setPreserveCase(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<98>() * ::capnp::ELEMENTS, value);
}

inline  ::uint32_t MinHash::Reader::getHashSeed() const {
  return _reader.getDataField< ::uint32_t>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS, 42u);
}

inline  ::uint32_t MinHash::Builder::getHashSeed() {
  return _builder.getDataField< ::uint32_t>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS, 42u);
}
inline void MinHash::Builder::setHashSeed( ::uint32_t value) {
  _builder.setDataField< ::uint32_t>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS, value, 42u);
}

inline bool MinHash::Reader::hasReferenceList() const {
  return !_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline bool MinHash::Builder::hasReferenceList() {
  return !_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::MinHash::ReferenceList::Reader MinHash::Reader::getReferenceList() const {
  return ::capnp::_::PointerHelpers< ::capnp::MinHash::ReferenceList>::get(_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline  ::capnp::MinHash::ReferenceList::Builder MinHash::Builder::getReferenceList() {
  return ::capnp::_::PointerHelpers< ::capnp::MinHash::ReferenceList>::get(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
#if !CAPNP_LITE
inline  ::capnp::MinHash::ReferenceList::Pipeline MinHash::Pipeline::getReferenceList() {
  return  ::capnp::MinHash::ReferenceList::Pipeline(_typeless.getPointerField(3));
}
#endif  // !CAPNP_LITE
inline void MinHash::Builder::setReferenceList( ::capnp::MinHash::ReferenceList::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::MinHash::ReferenceList>::set(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), value);
}
inline  ::capnp::MinHash::ReferenceList::Builder MinHash::Builder::initReferenceList() {
  return ::capnp::_::PointerHelpers< ::capnp::MinHash::ReferenceList>::init(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline void MinHash::Builder::adoptReferenceList(
    ::capnp::Orphan< ::capnp::MinHash::ReferenceList>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::MinHash::ReferenceList>::adopt(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::MinHash::ReferenceList> MinHash::Builder::disownReferenceList() {
  return ::capnp::_::PointerHelpers< ::capnp::MinHash::ReferenceList>::disown(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}

inline bool MinHash::ReferenceList::Reader::hasReferences() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool MinHash::ReferenceList::Builder::hasReferences() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::List< ::capnp::MinHash::ReferenceList::Reference,  ::capnp::Kind::STRUCT>::Reader MinHash::ReferenceList::Reader::getReferences() const {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::MinHash::ReferenceList::Reference,  ::capnp::Kind::STRUCT>>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::capnp::List< ::capnp::MinHash::ReferenceList::Reference,  ::capnp::Kind::STRUCT>::Builder MinHash::ReferenceList::Builder::getReferences() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::MinHash::ReferenceList::Reference,  ::capnp::Kind::STRUCT>>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void MinHash::ReferenceList::Builder::setReferences( ::capnp::List< ::capnp::MinHash::ReferenceList::Reference,  ::capnp::Kind::STRUCT>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::MinHash::ReferenceList::Reference,  ::capnp::Kind::STRUCT>>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::capnp::List< ::capnp::MinHash::ReferenceList::Reference,  ::capnp::Kind::STRUCT>::Builder MinHash::ReferenceList::Builder::initReferences(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::MinHash::ReferenceList::Reference,  ::capnp::Kind::STRUCT>>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void MinHash::ReferenceList::Builder::adoptReferences(
    ::capnp::Orphan< ::capnp::List< ::capnp::MinHash::ReferenceList::Reference,  ::capnp::Kind::STRUCT>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::MinHash::ReferenceList::Reference,  ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List< ::capnp::MinHash::ReferenceList::Reference,  ::capnp::Kind::STRUCT>> MinHash::ReferenceList::Builder::disownReferences() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::MinHash::ReferenceList::Reference,  ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline bool MinHash::ReferenceList::Reference::Reader::hasSequence() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool MinHash::ReferenceList::Reference::Builder::hasSequence() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader MinHash::ReferenceList::Reference::Reader::getSequence() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder MinHash::ReferenceList::Reference::Builder::getSequence() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void MinHash::ReferenceList::Reference::Builder::setSequence( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder MinHash::ReferenceList::Reference::Builder::initSequence(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void MinHash::ReferenceList::Reference::Builder::adoptSequence(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> MinHash::ReferenceList::Reference::Builder::disownSequence() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline bool MinHash::ReferenceList::Reference::Reader::hasQuality() const {
  return !_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline bool MinHash::ReferenceList::Reference::Builder::hasQuality() {
  return !_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader MinHash::ReferenceList::Reference::Reader::getQuality() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder MinHash::ReferenceList::Reference::Builder::getQuality() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline void MinHash::ReferenceList::Reference::Builder::setQuality( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder MinHash::ReferenceList::Reference::Builder::initQuality(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), size);
}
inline void MinHash::ReferenceList::Reference::Builder::adoptQuality(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> MinHash::ReferenceList::Reference::Builder::disownQuality() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}

inline  ::uint32_t MinHash::ReferenceList::Reference::Reader::getLength() const {
  return _reader.getDataField< ::uint32_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline  ::uint32_t MinHash::ReferenceList::Reference::Builder::getLength() {
  return _builder.getDataField< ::uint32_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void MinHash::ReferenceList::Reference::Builder::setLength( ::uint32_t value) {
  _builder.setDataField< ::uint32_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool MinHash::ReferenceList::Reference::Reader::hasName() const {
  return !_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline bool MinHash::ReferenceList::Reference::Builder::hasName() {
  return !_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader MinHash::ReferenceList::Reference::Reader::getName() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder MinHash::ReferenceList::Reference::Builder::getName() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline void MinHash::ReferenceList::Reference::Builder::setName( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder MinHash::ReferenceList::Reference::Builder::initName(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), size);
}
inline void MinHash::ReferenceList::Reference::Builder::adoptName(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> MinHash::ReferenceList::Reference::Builder::disownName() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}

inline bool MinHash::ReferenceList::Reference::Reader::hasComment() const {
  return !_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline bool MinHash::ReferenceList::Reference::Builder::hasComment() {
  return !_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader MinHash::ReferenceList::Reference::Reader::getComment() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder MinHash::ReferenceList::Reference::Builder::getComment() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline void MinHash::ReferenceList::Reference::Builder::setComment( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder MinHash::ReferenceList::Reference::Builder::initComment(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), size);
}
inline void MinHash::ReferenceList::Reference::Builder::adoptComment(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> MinHash::ReferenceList::Reference::Builder::disownComment() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}

inline bool MinHash::ReferenceList::Reference::Reader::hasHashes32() const {
  return !_reader.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS).isNull();
}
inline bool MinHash::ReferenceList::Reference::Builder::hasHashes32() {
  return !_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::List< ::uint32_t,  ::capnp::Kind::PRIMITIVE>::Reader MinHash::ReferenceList::Reference::Reader::getHashes32() const {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t,  ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}
inline  ::capnp::List< ::uint32_t,  ::capnp::Kind::PRIMITIVE>::Builder MinHash::ReferenceList::Reference::Builder::getHashes32() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t,  ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}
inline void MinHash::ReferenceList::Reference::Builder::setHashes32( ::capnp::List< ::uint32_t,  ::capnp::Kind::PRIMITIVE>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t,  ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), value);
}
inline void MinHash::ReferenceList::Reference::Builder::setHashes32(::kj::ArrayPtr<const  ::uint32_t> value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t,  ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), value);
}
inline  ::capnp::List< ::uint32_t,  ::capnp::Kind::PRIMITIVE>::Builder MinHash::ReferenceList::Reference::Builder::initHashes32(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t,  ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), size);
}
inline void MinHash::ReferenceList::Reference::Builder::adoptHashes32(
    ::capnp::Orphan< ::capnp::List< ::uint32_t,  ::capnp::Kind::PRIMITIVE>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t,  ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List< ::uint32_t,  ::capnp::Kind::PRIMITIVE>> MinHash::ReferenceList::Reference::Builder::disownHashes32() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t,  ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}

inline bool MinHash::ReferenceList::Reference::Reader::hasHashes64() const {
  return !_reader.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS).isNull();
}
inline bool MinHash::ReferenceList::Reference::Builder::hasHashes64() {
  return !_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::List< ::uint64_t,  ::capnp::Kind::PRIMITIVE>::Reader MinHash::ReferenceList::Reference::Reader::getHashes64() const {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t,  ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS));
}
inline  ::capnp::List< ::uint64_t,  ::capnp::Kind::PRIMITIVE>::Builder MinHash::ReferenceList::Reference::Builder::getHashes64() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t,  ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS));
}
inline void MinHash::ReferenceList::Reference::Builder::setHashes64( ::capnp::List< ::uint64_t,  ::capnp::Kind::PRIMITIVE>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t,  ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS), value);
}
inline void MinHash::ReferenceList::Reference::Builder::setHashes64(::kj::ArrayPtr<const  ::uint64_t> value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t,  ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS), value);
}
inline  ::capnp::List< ::uint64_t,  ::capnp::Kind::PRIMITIVE>::Builder MinHash::ReferenceList::Reference::Builder::initHashes64(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t,  ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS), size);
}
inline void MinHash::ReferenceList::Reference::Builder::adoptHashes64(
    ::capnp::Orphan< ::capnp::List< ::uint64_t,  ::capnp::Kind::PRIMITIVE>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t,  ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List< ::uint64_t,  ::capnp::Kind::PRIMITIVE>> MinHash::ReferenceList::Reference::Builder::disownHashes64() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t,  ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS));
}

inline  ::uint64_t MinHash::ReferenceList::Reference::Reader::getLength64() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t MinHash::ReferenceList::Reference::Builder::getLength64() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void MinHash::ReferenceList::Reference::Builder::setLength64( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline bool MinHash::ReferenceList::Reference::Reader::hasCounts32() const {
  return !_reader.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS).isNull();
}
inline bool MinHash::ReferenceList::Reference::Builder::hasCounts32() {
  return !_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::List< ::uint32_t,  ::capnp::Kind::PRIMITIVE>::Reader MinHash::ReferenceList::Reference::Reader::getCounts32() const {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t,  ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS));
}
inline  ::capnp::List< ::uint32_t,  ::capnp::Kind::PRIMITIVE>::Builder MinHash::ReferenceList::Reference::Builder::getCounts32() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t,  ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS));
}
inline void MinHash::ReferenceList::Reference::Builder::setCounts32( ::capnp::List< ::uint32_t,  ::capnp::Kind::PRIMITIVE>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t,  ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS), value);
}
inline void MinHash::ReferenceList::Reference::Builder::setCounts32(::kj::ArrayPtr<const  ::uint32_t> value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t,  ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS), value);
}
inline  ::capnp::List< ::uint32_t,  ::capnp::Kind::PRIMITIVE>::Builder MinHash::ReferenceList::Reference::Builder::initCounts32(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t,  ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS), size);
}
inline void MinHash::ReferenceList::Reference::Builder::adoptCounts32(
    ::capnp::Orphan< ::capnp::List< ::uint32_t,  ::capnp::Kind::PRIMITIVE>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t,  ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List< ::uint32_t,  ::capnp::Kind::PRIMITIVE>> MinHash::ReferenceList::Reference::Builder::disownCounts32() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t,  ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS));
}

inline bool MinHash::LocusList::Reader::hasLoci() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool MinHash::LocusList::Builder::hasLoci() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::List< ::capnp::MinHash::LocusList::Locus,  ::capnp::Kind::STRUCT>::Reader MinHash::LocusList::Reader::getLoci() const {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::MinHash::LocusList::Locus,  ::capnp::Kind::STRUCT>>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::capnp::List< ::capnp::MinHash::LocusList::Locus,  ::capnp::Kind::STRUCT>::Builder MinHash::LocusList::Builder::getLoci() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::MinHash::LocusList::Locus,  ::capnp::Kind::STRUCT>>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void MinHash::LocusList::Builder::setLoci( ::capnp::List< ::capnp::MinHash::LocusList::Locus,  ::capnp::Kind::STRUCT>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::MinHash::LocusList::Locus,  ::capnp::Kind::STRUCT>>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::capnp::List< ::capnp::MinHash::LocusList::Locus,  ::capnp::Kind::STRUCT>::Builder MinHash::LocusList::Builder::initLoci(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::MinHash::LocusList::Locus,  ::capnp::Kind::STRUCT>>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void MinHash::LocusList::Builder::adoptLoci(
    ::capnp::Orphan< ::capnp::List< ::capnp::MinHash::LocusList::Locus,  ::capnp::Kind::STRUCT>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::MinHash::LocusList::Locus,  ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List< ::capnp::MinHash::LocusList::Locus,  ::capnp::Kind::STRUCT>> MinHash::LocusList::Builder::disownLoci() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::MinHash::LocusList::Locus,  ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline  ::uint32_t MinHash::LocusList::Locus::Reader::getSequence() const {
  return _reader.getDataField< ::uint32_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline  ::uint32_t MinHash::LocusList::Locus::Builder::getSequence() {
  return _builder.getDataField< ::uint32_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void MinHash::LocusList::Locus::Builder::setSequence( ::uint32_t value) {
  _builder.setDataField< ::uint32_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline  ::uint32_t MinHash::LocusList::Locus::Reader::getPosition() const {
  return _reader.getDataField< ::uint32_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline  ::uint32_t MinHash::LocusList::Locus::Builder::getPosition() {
  return _builder.getDataField< ::uint32_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void MinHash::LocusList::Locus::Builder::setPosition( ::uint32_t value) {
  _builder.setDataField< ::uint32_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline  ::uint32_t MinHash::LocusList::Locus::Reader::getHash32() const {
  return _reader.getDataField< ::uint32_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline  ::uint32_t MinHash::LocusList::Locus::Builder::getHash32() {
  return _builder.getDataField< ::uint32_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void MinHash::LocusList::Locus::Builder::setHash32( ::uint32_t value) {
  _builder.setDataField< ::uint32_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t MinHash::LocusList::Locus::Reader::getHash64() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t MinHash::LocusList::Locus::Builder::getHash64() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void MinHash::LocusList::Locus::Builder::setHash64( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

}  // namespace

CAPNP_END_HEADER