StarPilot/openpilot/cereal/gen/cpp/custom.capnp.h

// Generated by Cap'n Proto compiler, DO NOT EDIT
// source: custom.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 != 1000001
#error "Version mismatch between generated code and library headers.  You must use the same version of the Cap'n Proto compiler and library."
#endif

#include <car.capnp.h>

CAPNP_BEGIN_HEADER

namespace capnp {
namespace schemas {

CAPNP_DECLARE_SCHEMA(81c2f05a394cf4af);
CAPNP_DECLARE_SCHEMA(be3bc47cd3284f3e);
CAPNP_DECLARE_SCHEMA(8d2ea0edb1a81e92);
enum class AudibleAlert_8d2ea0edb1a81e92: uint16_t {
  NONE,
  ENGAGE,
  DISENGAGE,
  REFUSE,
  WARNING_SOFT,
  WARNING_IMMEDIATE,
  PROMPT,
  PROMPT_REPEAT,
  PROMPT_DISTRACTED,
  ANGRY,
  CONTINUED,
  DEJA_VU,
  DOC,
  FART,
  FIREFOX,
  GOAT,
  HAL9000,
  MAIL,
  NESSIE,
  NOICE,
  STARTUP,
  THIS_IS_FINE,
  UWU,
};
CAPNP_DECLARE_ENUM(AudibleAlert, 8d2ea0edb1a81e92);
CAPNP_DECLARE_SCHEMA(d28ed59fbe1870aa);
CAPNP_DECLARE_SCHEMA(83e5f5472aa434b0);
CAPNP_DECLARE_SCHEMA(837ff4be1f1a9263);
CAPNP_DECLARE_SCHEMA(e4b42a95dcb60d90);
CAPNP_DECLARE_SCHEMA(d2fc84e59fa67897);
CAPNP_DECLARE_SCHEMA(98efbcb40a571c11);
CAPNP_DECLARE_SCHEMA(aedffd8f31e7b55d);
CAPNP_DECLARE_SCHEMA(b08e40777e122f6e);
CAPNP_DECLARE_SCHEMA(8d023a280a4db1b1);
CAPNP_DECLARE_SCHEMA(89da3b63569f65cc);
enum class Status_89da3b63569f65cc: uint16_t {
  UNAVAILABLE,
  COLLECTING,
  CANDIDATE,
  REJECTED,
  QUALIFIED_FIT,
};
CAPNP_DECLARE_ENUM(Status, 89da3b63569f65cc);
CAPNP_DECLARE_SCHEMA(b03bf8f7c878937a);
enum class Family_b03bf8f7c878937a: uint16_t {
  NONE,
  LINEAR_FACTOR,
  RUNTIME_PROFILE,
};
CAPNP_DECLARE_ENUM(Family, b03bf8f7c878937a);
CAPNP_DECLARE_SCHEMA(af3712fe799c76ce);
CAPNP_DECLARE_SCHEMA(f35cc4560bbf6ec2);
CAPNP_DECLARE_SCHEMA(918d19aa5875c92d);
CAPNP_DECLARE_SCHEMA(de92e382e2400293);
CAPNP_DECLARE_SCHEMA(da96579883444c35);
CAPNP_DECLARE_SCHEMA(a1680744031fdb2d);
CAPNP_DECLARE_SCHEMA(a7940385bedd1d4c);
CAPNP_DECLARE_SCHEMA(f58695a93b568caf);
CAPNP_DECLARE_SCHEMA(8d0881aa8fb47e88);
CAPNP_DECLARE_SCHEMA(e49b96e1e84aae65);
CAPNP_DECLARE_SCHEMA(fb41e1a738d832cb);
CAPNP_DECLARE_SCHEMA(9a4b2a0189fe1224);
enum class Choice_9a4b2a0189fe1224: uint16_t {
  STOCK,
  CONDITIONAL_EXPERIMENTAL,
  CONDITIONAL_CHILL,
};
CAPNP_DECLARE_ENUM(Choice, 9a4b2a0189fe1224);
CAPNP_DECLARE_SCHEMA(9ccdc8676701b412);
CAPNP_DECLARE_SCHEMA(b539e7c0aa8c1e69);
CAPNP_DECLARE_SCHEMA(8ba1f54de0ffaea9);
CAPNP_DECLARE_SCHEMA(b8cbd9e666181b95);
enum class Kind_b8cbd9e666181b95: uint16_t {
  UNKNOWN,
  ACCEPT,
  REJECT,
  ADOPT,
  CONDITIONAL_MODE_CYCLE,
  CRUISE_INCREASE,
  CRUISE_DECREASE,
  TRAFFIC_MODE_TOGGLE,
  SWITCHBACK_MODE_TOGGLE,
  CRUISE_SET,
  FORCE_COAST_TOGGLE,
  PULSE_GLIDE_TOGGLE,
  DISENGAGE_REQUEST,
};
CAPNP_DECLARE_ENUM(Kind, b8cbd9e666181b95);
CAPNP_DECLARE_SCHEMA(cd96dafb67a082d0);
CAPNP_DECLARE_SCHEMA(cc2db5640fb6dc61);
CAPNP_DECLARE_SCHEMA(9099c88083a9a9ff);
enum class Kind_9099c88083a9a9ff: uint16_t {
  UNKNOWN,
  DRIVER_CHANGE,
  CONFIRMATION_ACCEPT,
  CONFIRMATION_REJECT,
  COMMAND_APPLIED,
  COMMAND_REJECTED,
  CURVE_ACCEL_PRESS,
  CONDITIONAL_MODE,
  TRAFFIC_MODE,
  SWITCHBACK_MODE,
  WHEEL_ACTION,
  TESLA_STOCK_CRUISE,
};
CAPNP_DECLARE_ENUM(Kind, 9099c88083a9a9ff);
CAPNP_DECLARE_SCHEMA(c193365b5b96171a);
CAPNP_DECLARE_SCHEMA(b5fd4f3125925657);
enum class Button_b5fd4f3125925657: uint16_t {
  UNKNOWN,
  MODE,
  CUSTOM,
  DISTANCE,
};
CAPNP_DECLARE_ENUM(Button, b5fd4f3125925657);
CAPNP_DECLARE_SCHEMA(cd74aec758dc91fb);
enum class Press_cd74aec758dc91fb: uint16_t {
  UNKNOWN,
  SHORT,
  LONG,
  VERY_LONG,
};
CAPNP_DECLARE_ENUM(Press, cd74aec758dc91fb);
CAPNP_DECLARE_SCHEMA(fd07e0b91e3573c2);
enum class Button_fd07e0b91e3573c2: uint16_t {
  UNKNOWN,
  ACCEL,
  DECEL,
};
CAPNP_DECLARE_ENUM(Button, fd07e0b91e3573c2);
CAPNP_DECLARE_SCHEMA(efc922094a634c9f);
CAPNP_DECLARE_SCHEMA(d91859ee2d1548a6);
enum class Choice_d91859ee2d1548a6: uint16_t {
  STOCK,
  CONDITIONAL_EXPERIMENTAL,
  CONDITIONAL_CHILL,
};
CAPNP_DECLARE_ENUM(Choice, d91859ee2d1548a6);
CAPNP_DECLARE_SCHEMA(8203756f1dc64997);
enum class Button_8203756f1dc64997: uint16_t {
  UNKNOWN,
  LKAS,
  DISTANCE,
  MODE,
  CUSTOM,
};
CAPNP_DECLARE_ENUM(Button, 8203756f1dc64997);
CAPNP_DECLARE_SCHEMA(ca0ccb851ab794a1);
enum class Press_ca0ccb851ab794a1: uint16_t {
  UNKNOWN,
  SHORT,
  LONG,
  VERY_LONG,
};
CAPNP_DECLARE_ENUM(Press, ca0ccb851ab794a1);
CAPNP_DECLARE_SCHEMA(b057204d7deadf3f);
CAPNP_DECLARE_SCHEMA(d8cef65bd0f4669a);
enum class Status_d8cef65bd0f4669a: uint16_t {
  UNKNOWN,
  VALID,
  ABSENT,
  STALE,
};
CAPNP_DECLARE_ENUM(Status, d8cef65bd0f4669a);
CAPNP_DECLARE_SCHEMA(80ae746ee2596b11);
CAPNP_DECLARE_SCHEMA(ab5928774e6e64fc);
enum class TurnDirection_ab5928774e6e64fc: uint16_t {
  NONE,
  TURN_LEFT,
  TURN_RIGHT,
};
CAPNP_DECLARE_ENUM(TurnDirection, ab5928774e6e64fc);
CAPNP_DECLARE_SCHEMA(9e04a179bcb4ab72);
CAPNP_DECLARE_SCHEMA(c97a1c56dc1427ae);
enum class Status_c97a1c56dc1427ae: uint16_t {
  UNKNOWN,
  VALID,
  STALE,
  UNAVAILABLE,
};
CAPNP_DECLARE_ENUM(Status, c97a1c56dc1427ae);
CAPNP_DECLARE_SCHEMA(b45fd9e3634d228f);
enum class Stream_b45fd9e3634d228f: uint16_t {
  UNKNOWN,
  ROAD,
  WIDE_ROAD,
};
CAPNP_DECLARE_ENUM(Stream, b45fd9e3634d228f);
CAPNP_DECLARE_SCHEMA(a5cd762cd951a455);
CAPNP_DECLARE_SCHEMA(f98d843bfd7004a3);
CAPNP_DECLARE_SCHEMA(b86e6369214c01c8);
CAPNP_DECLARE_SCHEMA(c9cc35aa80c0f6d0);
CAPNP_DECLARE_SCHEMA(a3e9874fb61a67a9);
CAPNP_DECLARE_SCHEMA(a83b29386a085abf);
CAPNP_DECLARE_SCHEMA(f8f2bacc32be0684);
enum class Status_f8f2bacc32be0684: uint16_t {
  UNKNOWN,
  CLEAR,
  AMBIGUOUS,
};
CAPNP_DECLARE_ENUM(Status, f8f2bacc32be0684);
CAPNP_DECLARE_SCHEMA(881bde4407827145);
CAPNP_DECLARE_SCHEMA(f416ec09499d9d19);
CAPNP_DECLARE_SCHEMA(c0f486ad93ed68c9);
enum class AlertStatus_c0f486ad93ed68c9: uint16_t {
  NORMAL,
  USER_PROMPT,
  CRITICAL,
  STARPILOT,
};
CAPNP_DECLARE_ENUM(AlertStatus, c0f486ad93ed68c9);
CAPNP_DECLARE_SCHEMA(e22723d973fc2afb);
enum class AlertSize_e22723d973fc2afb: uint16_t {
  NONE,
  SMALL,
  MID,
  FULL,
};
CAPNP_DECLARE_ENUM(AlertSize, e22723d973fc2afb);
CAPNP_DECLARE_SCHEMA(b42d77eaa5b93711);
CAPNP_DECLARE_SCHEMA(cb9fd56c7057593a);
CAPNP_DECLARE_SCHEMA(c3709bd5f4f5b956);
CAPNP_DECLARE_SCHEMA(c74326beb04151ce);
CAPNP_DECLARE_SCHEMA(f187d96cea4f09df);
enum class Status_f187d96cea4f09df: uint16_t {
  UNKNOWN,
  CLEAR,
  WARNING,
};
CAPNP_DECLARE_ENUM(Status, f187d96cea4f09df);
CAPNP_DECLARE_SCHEMA(c2243c65e0340384);
CAPNP_DECLARE_SCHEMA(88f71f4263677d19);
CAPNP_DECLARE_SCHEMA(c5693d5da66b60b6);
CAPNP_DECLARE_SCHEMA(bd443b539493bc68);
CAPNP_DECLARE_SCHEMA(94d51b83b2a8ea50);
enum class Kind_94d51b83b2a8ea50: uint16_t {
  UNKNOWN,
  ADOPT_ACCEPTED_HIGHER_LIMIT,
  ADOPT_ACCEPTED_LIMIT,
};
CAPNP_DECLARE_ENUM(Kind, 94d51b83b2a8ea50);
CAPNP_DECLARE_SCHEMA(fc6241ed8877b611);
CAPNP_DECLARE_SCHEMA(da4149b4426ee957);
enum class FaultReason_da4149b4426ee957: uint16_t {
  UNKNOWN,
  NONE,
  TRANSPORT_PAUSE,
  CRITICAL,
  AVAILABILITY_PAUSE,
};
CAPNP_DECLARE_ENUM(FaultReason, da4149b4426ee957);
CAPNP_DECLARE_SCHEMA(b63a8514b8adccf9);
enum class Mode_b63a8514b8adccf9: uint16_t {
  OFF,
  LATERAL_ONLY,
  LONGITUDINAL_ONLY,
  COMBINED,
};
CAPNP_DECLARE_ENUM(Mode, b63a8514b8adccf9);
CAPNP_DECLARE_SCHEMA(aa8ad10b494a5535);
CAPNP_DECLARE_SCHEMA(d588f23cdc13abdb);
CAPNP_DECLARE_SCHEMA(c255773d8fee1e7d);
CAPNP_DECLARE_SCHEMA(a042ddb70aba3ea9);
CAPNP_DECLARE_SCHEMA(96f223681662db77);
enum class Phase_96f223681662db77: uint16_t {
  MANUAL_REQUIRED,
  WAITING_FOR_DELAY,
  LANE_UNAVAILABLE,
  BLINDSPOT_BLOCKED,
};
CAPNP_DECLARE_ENUM(Phase, 96f223681662db77);
CAPNP_DECLARE_SCHEMA(8e8c74910fed948f);
enum class Direction_8e8c74910fed948f: uint16_t {
  NONE,
  LEFT,
  RIGHT,
};
CAPNP_DECLARE_ENUM(Direction, 8e8c74910fed948f);
CAPNP_DECLARE_SCHEMA(a30662f84033036c);
CAPNP_DECLARE_SCHEMA(ff889853e7b0987f);
CAPNP_DECLARE_SCHEMA(faa35dcac85073a2);
CAPNP_DECLARE_SCHEMA(d6f78acca1bc3939);
CAPNP_DECLARE_SCHEMA(de9705979aca8339);
CAPNP_DECLARE_SCHEMA(c86a3d38d13eb3ef);
CAPNP_DECLARE_SCHEMA(859f26628fc24358);
enum class MapdInputType_859f26628fc24358: uint16_t {
  DOWNLOAD,
  SET_TARGET_LATERAL_ACCEL,
  SET_SPEED_LIMIT_OFFSET,
  SET_SPEED_LIMIT_CONTROL,
  SET_MAP_CURVE_SPEED_CONTROL,
  SET_VISION_CURVE_SPEED_CONTROL,
  SET_LOG_LEVEL,
  SET_VISION_CURVE_TARGET_LAT_A,
  SET_VISION_CURVE_MIN_TARGET_V,
  RELOAD_SETTINGS,
  SAVE_SETTINGS,
  SET_ENABLE_SPEED,
  SET_VISION_CURVE_USE_ENABLE_SPEED,
  SET_MAP_CURVE_USE_ENABLE_SPEED,
  SET_SPEED_LIMIT_USE_ENABLE_SPEED,
  SET_HOLD_LAST_SEEN_SPEED_LIMIT,
  SET_TARGET_SPEED_JERK,
  SET_TARGET_SPEED_ACCEL,
  SET_TARGET_SPEED_TIME_OFFSET,
  SET_DEFAULT_LANE_WIDTH,
  SET_MAP_CURVE_TARGET_LAT_A,
  LOAD_DEFAULT_SETTINGS,
  LOAD_RECOMMENDED_SETTINGS,
  SET_SLOW_DOWN_FOR_NEXT_SPEED_LIMIT,
  SET_SPEED_UP_FOR_NEXT_SPEED_LIMIT,
  SET_HOLD_SPEED_LIMIT_WHILE_CHANGING_SET_SPEED,
  LOAD_PERSISTENT_SETTINGS,
  CANCEL_DOWNLOAD,
  SET_LOG_JSON,
  SET_LOG_SOURCE,
  SET_EXTERNAL_SPEED_LIMIT_CONTROL,
  SET_EXTERNAL_SPEED_LIMIT,
  SET_SPEED_LIMIT_PRIORITY,
  SET_SPEED_LIMIT_CHANGE_REQUIRES_ACCEPT,
  ACCEPT_SPEED_LIMIT,
  SET_PRESS_GAS_TO_ACCEPT_SPEED_LIMIT,
  SET_ADJUST_SET_SPEED_TO_ACCEPT_SPEED_LIMIT,
  SET_ACCEPT_SPEED_LIMIT_TIMEOUT,
  SET_PRESS_GAS_TO_OVERRIDE_SPEED_LIMIT,
  SET_CONDITIONAL_SPEED_LIMIT_CONTROL,
  SET_SHADOW_CAR_STATE,
  SET_SHADOW_MODEL_V2,
  SET_SHADOW_GPS_LOCATION,
  SET_JSON_PATH_FLOAT,
  SET_JSON_PATH_TEXT,
  SET_JSON_PATH_BOOL,
  SET_SHADOW_GPS_LOCATION_EXTERNAL,
};
CAPNP_DECLARE_ENUM(MapdInputType, 859f26628fc24358);
CAPNP_DECLARE_SCHEMA(a4f1eb3323f5f582);
CAPNP_DECLARE_SCHEMA(965a7a6975ef2b9e);
enum class SampleStatus_965a7a6975ef2b9e: uint16_t {
  UNKNOWN,
  NO_GPS,
  NO_COVERAGE,
  NO_MATCH,
  MATCHED_NO_LIMIT,
  MATCHED_LIMIT,
};
CAPNP_DECLARE_ENUM(SampleStatus, 965a7a6975ef2b9e);
CAPNP_DECLARE_SCHEMA(f2b4452cefd6d128);
enum class GpsSource_f2b4452cefd6d128: uint16_t {
  NONE,
  INTERNAL,
  EXTERNAL,
  CAR,
};
CAPNP_DECLARE_ENUM(GpsSource, f2b4452cefd6d128);
CAPNP_DECLARE_SCHEMA(abefa88b9563dbae);
enum class RoadContext_abefa88b9563dbae: uint16_t {
  FREEWAY,
  CITY,
  UNKNOWN,
};
CAPNP_DECLARE_ENUM(RoadContext, abefa88b9563dbae);
CAPNP_DECLARE_SCHEMA(fa3e5ce74e25e82a);
enum class WaySelectionType_fa3e5ce74e25e82a: uint16_t {
  CURRENT,
  PREDICTED,
  POSSIBLE,
  EXTENDED,
  FAIL,
};
CAPNP_DECLARE_ENUM(WaySelectionType, fa3e5ce74e25e82a);
CAPNP_DECLARE_SCHEMA(d18274dcdc63c41d);
enum class HighwayClass_d18274dcdc63c41d: uint16_t {
  UNKNOWN,
  MOTORWAY,
  MOTORWAY_LINK,
  TRUNK,
  TRUNK_LINK,
  PRIMARY,
  PRIMARY_LINK,
  SECONDARY,
  SECONDARY_LINK,
  TERTIARY,
  TERTIARY_LINK,
  UNCLASSIFIED,
  RESIDENTIAL,
  LIVING_STREET,
};
CAPNP_DECLARE_ENUM(HighwayClass, d18274dcdc63c41d);
CAPNP_DECLARE_SCHEMA(f2447170bb68f358);
CAPNP_DECLARE_SCHEMA(c9c9b325ca50aaf7);
CAPNP_DECLARE_SCHEMA(ddd8eb0f1a3fb843);
CAPNP_DECLARE_SCHEMA(e7b005eb931864bc);
CAPNP_DECLARE_SCHEMA(bab0f51a74ffee6e);
CAPNP_DECLARE_SCHEMA(ef38d302825641e3);
CAPNP_DECLARE_SCHEMA(dc64b4c2a8d2325e);
CAPNP_DECLARE_SCHEMA(db7a34fdbdd1d9f7);
CAPNP_DECLARE_SCHEMA(c67bb160599bcae3);
CAPNP_DECLARE_SCHEMA(f967f623f65d7dba);
CAPNP_DECLARE_SCHEMA(ccffb4ab144bf131);
CAPNP_DECLARE_SCHEMA(9fe2d23e75805149);
CAPNP_DECLARE_SCHEMA(82b6c8ea6a6efabd);
CAPNP_DECLARE_SCHEMA(d1dfbadb6a811fee);
CAPNP_DECLARE_SCHEMA(b276dede9e6b2cc4);
CAPNP_DECLARE_SCHEMA(ab0b33cac682523e);
CAPNP_DECLARE_SCHEMA(f078f562cbce49ad);
CAPNP_DECLARE_SCHEMA(9f853f7eb4110c72);
CAPNP_DECLARE_SCHEMA(e6f67224bc0ee1a3);
CAPNP_DECLARE_SCHEMA(ec37375f3ac20926);
CAPNP_DECLARE_SCHEMA(db85b982067f1bc1);
CAPNP_DECLARE_SCHEMA(ef6257bed9318012);
CAPNP_DECLARE_SCHEMA(bbb8f17940692312);
CAPNP_DECLARE_SCHEMA(daa1a9f0d8968e31);

}  // namespace schemas
}  // namespace capnp

namespace cereal {

struct StarPilotCarControl {
  StarPilotCarControl() = delete;

  class Reader;
  class Builder;
  class Pipeline;
  struct HUDControl;
  struct SteeringLimitInfo;
  struct Navigation;
  struct PreapRadarStartup;
  struct PreapPedalStartup;

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

struct StarPilotCarControl::HUDControl {
  HUDControl() = delete;

  class Reader;
  class Builder;
  class Pipeline;
  typedef ::capnp::schemas::AudibleAlert_8d2ea0edb1a81e92 AudibleAlert;


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

struct StarPilotCarControl::SteeringLimitInfo {
  SteeringLimitInfo() = delete;

  class Reader;
  class Builder;
  class Pipeline;

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

struct StarPilotCarControl::Navigation {
  Navigation() = delete;

  class Reader;
  class Builder;
  class Pipeline;
  struct Coordinate;
  struct Instruction;

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

struct StarPilotCarControl::Navigation::Coordinate {
  Coordinate() = delete;

  class Reader;
  class Builder;
  class Pipeline;

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

struct StarPilotCarControl::Navigation::Instruction {
  Instruction() = delete;

  class Reader;
  class Builder;
  class Pipeline;

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

struct StarPilotCarControl::PreapRadarStartup {
  PreapRadarStartup() = delete;

  class Reader;
  class Builder;
  class Pipeline;

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

struct StarPilotCarControl::PreapPedalStartup {
  PreapPedalStartup() = delete;

  class Reader;
  class Builder;
  class Pipeline;

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

struct StarPilotCarParams {
  StarPilotCarParams() = delete;

  class Reader;
  class Builder;
  class Pipeline;
  struct SafetyConfig;
  struct AutoSteeringLearning;

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

struct StarPilotCarParams::SafetyConfig {
  SafetyConfig() = delete;

  class Reader;
  class Builder;
  class Pipeline;

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

struct StarPilotCarParams::AutoSteeringLearning {
  AutoSteeringLearning() = delete;

  class Reader;
  class Builder;
  class Pipeline;
  typedef ::capnp::schemas::Status_89da3b63569f65cc Status;

  typedef ::capnp::schemas::Family_b03bf8f7c878937a Family;

  struct Identity;

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

struct StarPilotCarParams::AutoSteeringLearning::Identity {
  Identity() = delete;

  class Reader;
  class Builder;
  class Pipeline;

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

struct StarPilotCarState {
  StarPilotCarState() = delete;

  class Reader;
  class Builder;
  class Pipeline;
  struct Gps;
  struct FeedbackPublication;

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

struct StarPilotCarState::Gps {
  Gps() = delete;

  class Reader;
  class Builder;
  class Pipeline;

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

struct StarPilotCarState::FeedbackPublication {
  FeedbackPublication() = delete;

  class Reader;
  class Builder;
  class Pipeline;

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

struct StarPilotLongitudinalPlan {
  StarPilotLongitudinalPlan() = delete;

  class Reader;
  class Builder;
  class Pipeline;

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

struct SlcState {
  SlcState() = delete;

  class Reader;
  class Builder;
  class Pipeline;
  struct SourceReading;
  struct SwitchbackModeState;
  struct TrafficModeState;
  struct CurveState;
  struct ConditionalModeState;

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

struct SlcState::SourceReading {
  SourceReading() = delete;

  class Reader;
  class Builder;
  class Pipeline;

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

struct SlcState::SwitchbackModeState {
  SwitchbackModeState() = delete;

  class Reader;
  class Builder;
  class Pipeline;

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

struct SlcState::TrafficModeState {
  TrafficModeState() = delete;

  class Reader;
  class Builder;
  class Pipeline;

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

struct SlcState::CurveState {
  CurveState() = delete;

  class Reader;
  class Builder;
  class Pipeline;

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

struct SlcState::ConditionalModeState {
  ConditionalModeState() = delete;

  class Reader;
  class Builder;
  class Pipeline;
  typedef ::capnp::schemas::Choice_9a4b2a0189fe1224 Choice;


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

struct SlcAction {
  SlcAction() = delete;

  class Reader;
  class Builder;
  class Pipeline;
  struct ControllerCruiseAction;
  struct ConditionalManualAction;
  typedef ::capnp::schemas::Kind_b8cbd9e666181b95 Kind;


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

struct SlcAction::ControllerCruiseAction {
  ControllerCruiseAction() = delete;

  class Reader;
  class Builder;
  class Pipeline;

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

struct SlcAction::ConditionalManualAction {
  ConditionalManualAction() = delete;

  class Reader;
  class Builder;
  class Pipeline;

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

struct SlcCruiseEvent {
  SlcCruiseEvent() = delete;

  class Reader;
  class Builder;
  class Pipeline;
  struct TeslaStockCruise;
  typedef ::capnp::schemas::Kind_9099c88083a9a9ff Kind;

  struct TrafficModeGesture;
  typedef ::capnp::schemas::Button_fd07e0b91e3573c2 Button;

  struct ManualModeGesture;

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

struct SlcCruiseEvent::TeslaStockCruise {
  TeslaStockCruise() = delete;

  class Reader;
  class Builder;
  class Pipeline;

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

struct SlcCruiseEvent::TrafficModeGesture {
  TrafficModeGesture() = delete;

  class Reader;
  class Builder;
  class Pipeline;
  typedef ::capnp::schemas::Button_b5fd4f3125925657 Button;

  typedef ::capnp::schemas::Press_cd74aec758dc91fb Press;


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

struct SlcCruiseEvent::ManualModeGesture {
  ManualModeGesture() = delete;

  class Reader;
  class Builder;
  class Pipeline;
  typedef ::capnp::schemas::Choice_d91859ee2d1548a6 Choice;

  typedef ::capnp::schemas::Button_8203756f1dc64997 Button;

  typedef ::capnp::schemas::Press_ca0ccb851ab794a1 Press;


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

struct SlcDashboardObservation {
  SlcDashboardObservation() = delete;

  class Reader;
  class Builder;
  class Pipeline;
  typedef ::capnp::schemas::Status_d8cef65bd0f4669a Status;


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

struct StarPilotModelDataV2 {
  StarPilotModelDataV2() = delete;

  class Reader;
  class Builder;
  class Pipeline;
  typedef ::capnp::schemas::TurnDirection_ab5928774e6e64fc TurnDirection;

  struct VisionObservation;

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

struct StarPilotModelDataV2::VisionObservation {
  VisionObservation() = delete;

  class Reader;
  class Builder;
  class Pipeline;
  typedef ::capnp::schemas::Status_c97a1c56dc1427ae Status;

  typedef ::capnp::schemas::Stream_b45fd9e3634d228f Stream;


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

struct StarPilotSteeringTracking {
  StarPilotSteeringTracking() = delete;

  class Reader;
  class Builder;
  class Pipeline;

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

struct CustomReserved6 {
  CustomReserved6() = delete;

  class Reader;
  class Builder;
  class Pipeline;

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

struct StarPilotRadarState {
  StarPilotRadarState() = delete;

  class Reader;
  class Builder;
  class Pipeline;
  struct AdjacentStopped;
  struct LeadData;
  struct QualifiedAdjacent;

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

struct StarPilotRadarState::AdjacentStopped {
  AdjacentStopped() = delete;

  class Reader;
  class Builder;
  class Pipeline;

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

struct StarPilotRadarState::LeadData {
  LeadData() = delete;

  class Reader;
  class Builder;
  class Pipeline;

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

struct StarPilotRadarState::QualifiedAdjacent {
  QualifiedAdjacent() = delete;

  class Reader;
  class Builder;
  class Pipeline;
  typedef ::capnp::schemas::Status_f8f2bacc32be0684 Status;

  struct Candidate;

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

struct StarPilotRadarState::QualifiedAdjacent::Candidate {
  Candidate() = delete;

  class Reader;
  class Builder;
  class Pipeline;

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

struct StarPilotSelfdriveState {
  StarPilotSelfdriveState() = delete;

  class Reader;
  class Builder;
  class Pipeline;
  typedef ::capnp::schemas::AlertStatus_c0f486ad93ed68c9 AlertStatus;

  typedef ::capnp::schemas::AlertSize_e22723d973fc2afb AlertSize;

  struct ConditionalModeAck;

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

struct StarPilotSelfdriveState::ConditionalModeAck {
  ConditionalModeAck() = delete;

  class Reader;
  class Builder;
  class Pipeline;

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

struct SpotMonitorState {
  SpotMonitorState() = delete;

  class Reader;
  class Builder;
  class Pipeline;
  struct Observation;

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

struct SpotMonitorState::Observation {
  Observation() = delete;

  class Reader;
  class Builder;
  class Pipeline;
  struct Side;

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

struct SpotMonitorState::Observation::Side {
  Side() = delete;

  class Reader;
  class Builder;
  class Pipeline;
  typedef ::capnp::schemas::Status_f187d96cea4f09df Status;


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

struct StarPilotLateralState {
  StarPilotLateralState() = delete;

  class Reader;
  class Builder;
  class Pipeline;
  struct LaneCentering;
  struct FeedbackConsumption;

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

struct StarPilotLateralState::LaneCentering {
  LaneCentering() = delete;

  class Reader;
  class Builder;
  class Pipeline;

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

struct StarPilotLateralState::FeedbackConsumption {
  FeedbackConsumption() = delete;

  class Reader;
  class Builder;
  class Pipeline;

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

struct SlcCruiseCommand {
  SlcCruiseCommand() = delete;

  class Reader;
  class Builder;
  class Pipeline;
  typedef ::capnp::schemas::Kind_94d51b83b2a8ea50 Kind;


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

struct AolAxisState {
  AolAxisState() = delete;

  class Reader;
  class Builder;
  class Pipeline;
  typedef ::capnp::schemas::FaultReason_da4149b4426ee957 FaultReason;

  typedef ::capnp::schemas::Mode_b63a8514b8adccf9 Mode;

  struct SafetyWire;
  struct IntentWire;
  struct LaneChangeStatusWire;

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

struct AolAxisState::SafetyWire {
  SafetyWire() = delete;

  class Reader;
  class Builder;
  class Pipeline;
  struct PandaSlot;

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

struct AolAxisState::SafetyWire::PandaSlot {
  PandaSlot() = delete;

  class Reader;
  class Builder;
  class Pipeline;

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

struct AolAxisState::IntentWire {
  IntentWire() = delete;

  class Reader;
  class Builder;
  class Pipeline;

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

struct AolAxisState::LaneChangeStatusWire {
  LaneChangeStatusWire() = delete;

  class Reader;
  class Builder;
  class Pipeline;
  typedef ::capnp::schemas::Phase_96f223681662db77 Phase;

  typedef ::capnp::schemas::Direction_8e8c74910fed948f Direction;


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

struct MapdExtendedOut {
  MapdExtendedOut() = delete;

  class Reader;
  class Builder;
  class Pipeline;
  struct MapdDownloadLocationDetails;
  struct MapdDownloadProgress;
  struct MapdPathPoint;
  struct MapdPosition;

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

struct MapdExtendedOut::MapdDownloadLocationDetails {
  MapdDownloadLocationDetails() = delete;

  class Reader;
  class Builder;
  class Pipeline;

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

struct MapdExtendedOut::MapdDownloadProgress {
  MapdDownloadProgress() = delete;

  class Reader;
  class Builder;
  class Pipeline;

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

struct MapdExtendedOut::MapdPathPoint {
  MapdPathPoint() = delete;

  class Reader;
  class Builder;
  class Pipeline;

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

struct MapdExtendedOut::MapdPosition {
  MapdPosition() = delete;

  class Reader;
  class Builder;
  class Pipeline;

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

struct MapdIn {
  MapdIn() = delete;

  class Reader;
  class Builder;
  class Pipeline;
  typedef ::capnp::schemas::MapdInputType_859f26628fc24358 MapdInputType;


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

struct MapdOut {
  MapdOut() = delete;

  class Reader;
  class Builder;
  class Pipeline;
  typedef ::capnp::schemas::SampleStatus_965a7a6975ef2b9e SampleStatus;

  typedef ::capnp::schemas::GpsSource_f2b4452cefd6d128 GpsSource;

  typedef ::capnp::schemas::RoadContext_abefa88b9563dbae RoadContext;

  typedef ::capnp::schemas::WaySelectionType_fa3e5ce74e25e82a WaySelectionType;

  typedef ::capnp::schemas::HighwayClass_d18274dcdc63c41d HighwayClass;


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

struct LearningControlEvidence {
  LearningControlEvidence() = delete;

  class Reader;
  class Builder;
  class Pipeline;
  struct FullEffectTrace;
  struct NamedValue;
  struct StageValue;

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

struct LearningControlEvidence::FullEffectTrace {
  FullEffectTrace() = delete;

  class Reader;
  class Builder;
  class Pipeline;

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

struct LearningControlEvidence::NamedValue {
  NamedValue() = delete;

  class Reader;
  class Builder;
  class Pipeline;
  enum Which: uint16_t {
    NUMBER,
    TEXT,
    BOOLEAN,
  };

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

struct LearningControlEvidence::StageValue {
  StageValue() = delete;

  class Reader;
  class Builder;
  class Pipeline;

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

struct LearningAppliedEvidence {
  LearningAppliedEvidence() = delete;

  class Reader;
  class Builder;
  class Pipeline;

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

struct AutomaticRuntimeProfile {
  AutomaticRuntimeProfile() = delete;

  class Reader;
  class Builder;
  class Pipeline;
  struct FullSurfaceEnvelope;
  struct ReplayValidation;
  struct Parameter;
  struct CohortImprovement;

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

struct AutomaticRuntimeProfile::FullSurfaceEnvelope {
  FullSurfaceEnvelope() = delete;

  class Reader;
  class Builder;
  class Pipeline;
  struct Coordinate;

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

struct AutomaticRuntimeProfile::FullSurfaceEnvelope::Coordinate {
  Coordinate() = delete;

  class Reader;
  class Builder;
  class Pipeline;

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

struct AutomaticRuntimeProfile::ReplayValidation {
  ReplayValidation() = delete;

  class Reader;
  class Builder;
  class Pipeline;

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

struct AutomaticRuntimeProfile::Parameter {
  Parameter() = delete;

  class Reader;
  class Builder;
  class Pipeline;

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

struct AutomaticRuntimeProfile::CohortImprovement {
  CohortImprovement() = delete;

  class Reader;
  class Builder;
  class Pipeline;

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

struct AutomaticLearningSourceReceipt {
  AutomaticLearningSourceReceipt() = delete;

  class Reader;
  class Builder;
  class Pipeline;

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

struct LearningApplication {
  LearningApplication() = delete;

  class Reader;
  class Builder;
  class Pipeline;

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

struct FordLearningEvidence {
  FordLearningEvidence() = delete;

  class Reader;
  class Builder;
  class Pipeline;

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

struct FordLearningEvent {
  FordLearningEvent() = delete;

  class Reader;
  class Builder;
  class Pipeline;

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

struct CentreApplicationWitness {
  CentreApplicationWitness() = delete;

  class Reader;
  class Builder;
  class Pipeline;

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

struct LearningTorqueProjection {
  LearningTorqueProjection() = delete;

  class Reader;
  class Builder;
  class Pipeline;

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

struct LiveTrackingBinding {
  LiveTrackingBinding() = delete;

  class Reader;
  class Builder;
  class Pipeline;

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

struct LiveTrackingTrial {
  LiveTrackingTrial() = delete;

  class Reader;
  class Builder;
  class Pipeline;
  struct Coordinate;

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

struct LiveTrackingTrial::Coordinate {
  Coordinate() = delete;

  class Reader;
  class Builder;
  class Pipeline;

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

struct LiveTrackingApplication {
  LiveTrackingApplication() = delete;

  class Reader;
  class Builder;
  class Pipeline;

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

struct LiveTrackingRestore {
  LiveTrackingRestore() = delete;

  class Reader;
  class Builder;
  class Pipeline;

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

struct LiveTrackingResponseCertificate {
  LiveTrackingResponseCertificate() = delete;

  class Reader;
  class Builder;
  class Pipeline;

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

struct LiveTrackingResponseWitness {
  LiveTrackingResponseWitness() = delete;

  class Reader;
  class Builder;
  class Pipeline;

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

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

class StarPilotCarControl::Reader {
public:
  typedef StarPilotCarControl 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 hasHudControl() const;
  inline  ::cereal::StarPilotCarControl::HUDControl::Reader getHudControl() const;

  inline bool hasSteeringLimitInfo() const;
  inline  ::cereal::StarPilotCarControl::SteeringLimitInfo::Reader getSteeringLimitInfo() const;

  inline bool hasNavigation() const;
  inline  ::cereal::StarPilotCarControl::Navigation::Reader getNavigation() const;

  inline bool hasPhoneGps() const;
  inline  ::cereal::StarPilotCarState::Gps::Reader getPhoneGps() 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 StarPilotCarControl::Builder {
public:
  typedef StarPilotCarControl 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 hasHudControl();
  inline  ::cereal::StarPilotCarControl::HUDControl::Builder getHudControl();
  inline void setHudControl( ::cereal::StarPilotCarControl::HUDControl::Reader value);
  inline  ::cereal::StarPilotCarControl::HUDControl::Builder initHudControl();
  inline void adoptHudControl(::capnp::Orphan< ::cereal::StarPilotCarControl::HUDControl>&& value);
  inline ::capnp::Orphan< ::cereal::StarPilotCarControl::HUDControl> disownHudControl();

  inline bool hasSteeringLimitInfo();
  inline  ::cereal::StarPilotCarControl::SteeringLimitInfo::Builder getSteeringLimitInfo();
  inline void setSteeringLimitInfo( ::cereal::StarPilotCarControl::SteeringLimitInfo::Reader value);
  inline  ::cereal::StarPilotCarControl::SteeringLimitInfo::Builder initSteeringLimitInfo();
  inline void adoptSteeringLimitInfo(::capnp::Orphan< ::cereal::StarPilotCarControl::SteeringLimitInfo>&& value);
  inline ::capnp::Orphan< ::cereal::StarPilotCarControl::SteeringLimitInfo> disownSteeringLimitInfo();

  inline bool hasNavigation();
  inline  ::cereal::StarPilotCarControl::Navigation::Builder getNavigation();
  inline void setNavigation( ::cereal::StarPilotCarControl::Navigation::Reader value);
  inline  ::cereal::StarPilotCarControl::Navigation::Builder initNavigation();
  inline void adoptNavigation(::capnp::Orphan< ::cereal::StarPilotCarControl::Navigation>&& value);
  inline ::capnp::Orphan< ::cereal::StarPilotCarControl::Navigation> disownNavigation();

  inline bool hasPhoneGps();
  inline  ::cereal::StarPilotCarState::Gps::Builder getPhoneGps();
  inline void setPhoneGps( ::cereal::StarPilotCarState::Gps::Reader value);
  inline  ::cereal::StarPilotCarState::Gps::Builder initPhoneGps();
  inline void adoptPhoneGps(::capnp::Orphan< ::cereal::StarPilotCarState::Gps>&& value);
  inline ::capnp::Orphan< ::cereal::StarPilotCarState::Gps> disownPhoneGps();

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 StarPilotCarControl::Pipeline {
public:
  typedef StarPilotCarControl Pipelines;

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

  inline  ::cereal::StarPilotCarControl::HUDControl::Pipeline getHudControl();
  inline  ::cereal::StarPilotCarControl::SteeringLimitInfo::Pipeline getSteeringLimitInfo();
  inline  ::cereal::StarPilotCarControl::Navigation::Pipeline getNavigation();
  inline  ::cereal::StarPilotCarState::Gps::Pipeline getPhoneGps();
private:
  ::capnp::AnyPointer::Pipeline _typeless;
  friend class ::capnp::PipelineHook;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
};
#endif  // !CAPNP_LITE

class StarPilotCarControl::HUDControl::Reader {
public:
  typedef HUDControl 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  ::cereal::StarPilotCarControl::HUDControl::AudibleAlert getAudibleAlert() 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 StarPilotCarControl::HUDControl::Builder {
public:
  typedef HUDControl 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  ::cereal::StarPilotCarControl::HUDControl::AudibleAlert getAudibleAlert();
  inline void setAudibleAlert( ::cereal::StarPilotCarControl::HUDControl::AudibleAlert 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 StarPilotCarControl::HUDControl::Pipeline {
public:
  typedef HUDControl 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 StarPilotCarControl::SteeringLimitInfo::Reader {
public:
  typedef SteeringLimitInfo 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 getValid() const;

  inline float getModelLimitErrorDeg() const;

  inline float getResumeLimitErrorDeg() const;

  inline float getCooperativeLimitErrorDeg() const;

  inline float getCooperativeOffsetDeg() const;

  inline  ::uint64_t getMonoTime() const;

  inline float getCombinedLimitErrorDeg() 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 StarPilotCarControl::SteeringLimitInfo::Builder {
public:
  typedef SteeringLimitInfo 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 getValid();
  inline void setValid(bool value);

  inline float getModelLimitErrorDeg();
  inline void setModelLimitErrorDeg(float value);

  inline float getResumeLimitErrorDeg();
  inline void setResumeLimitErrorDeg(float value);

  inline float getCooperativeLimitErrorDeg();
  inline void setCooperativeLimitErrorDeg(float value);

  inline float getCooperativeOffsetDeg();
  inline void setCooperativeOffsetDeg(float value);

  inline  ::uint64_t getMonoTime();
  inline void setMonoTime( ::uint64_t value);

  inline float getCombinedLimitErrorDeg();
  inline void setCombinedLimitErrorDeg(float 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 StarPilotCarControl::SteeringLimitInfo::Pipeline {
public:
  typedef SteeringLimitInfo 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 StarPilotCarControl::Navigation::Reader {
public:
  typedef Navigation 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 hasSessionId() const;
  inline  ::capnp::Text::Reader getSessionId() const;

  inline  ::uint64_t getFrameMonoTime() const;

  inline  ::uint64_t getStartedMonoTime() const;

  inline bool hasRevision() const;
  inline  ::capnp::Text::Reader getRevision() const;

  inline bool getEnabled() const;

  inline bool hasStatus() const;
  inline  ::capnp::Text::Reader getStatus() const;

  inline bool hasDestinationName() const;
  inline  ::capnp::Text::Reader getDestinationName() const;

  inline bool hasInstruction() const;
  inline  ::cereal::StarPilotCarControl::Navigation::Instruction::Reader getInstruction() const;

  inline bool hasRoute() const;
  inline  ::capnp::List< ::cereal::StarPilotCarControl::Navigation::Coordinate,  ::capnp::Kind::STRUCT>::Reader getRoute() const;

  inline bool hasNextManeuver() const;
  inline  ::cereal::StarPilotCarControl::Navigation::Instruction::Reader getNextManeuver() const;

  inline  ::uint64_t getLocationMonoTime() const;

  inline bool getControlValid() const;

  inline  ::uint16_t getVersion() 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 StarPilotCarControl::Navigation::Builder {
public:
  typedef Navigation 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 hasSessionId();
  inline  ::capnp::Text::Builder getSessionId();
  inline void setSessionId( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initSessionId(unsigned int size);
  inline void adoptSessionId(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownSessionId();

  inline  ::uint64_t getFrameMonoTime();
  inline void setFrameMonoTime( ::uint64_t value);

  inline  ::uint64_t getStartedMonoTime();
  inline void setStartedMonoTime( ::uint64_t value);

  inline bool hasRevision();
  inline  ::capnp::Text::Builder getRevision();
  inline void setRevision( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initRevision(unsigned int size);
  inline void adoptRevision(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownRevision();

  inline bool getEnabled();
  inline void setEnabled(bool value);

  inline bool hasStatus();
  inline  ::capnp::Text::Builder getStatus();
  inline void setStatus( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initStatus(unsigned int size);
  inline void adoptStatus(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownStatus();

  inline bool hasDestinationName();
  inline  ::capnp::Text::Builder getDestinationName();
  inline void setDestinationName( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initDestinationName(unsigned int size);
  inline void adoptDestinationName(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownDestinationName();

  inline bool hasInstruction();
  inline  ::cereal::StarPilotCarControl::Navigation::Instruction::Builder getInstruction();
  inline void setInstruction( ::cereal::StarPilotCarControl::Navigation::Instruction::Reader value);
  inline  ::cereal::StarPilotCarControl::Navigation::Instruction::Builder initInstruction();
  inline void adoptInstruction(::capnp::Orphan< ::cereal::StarPilotCarControl::Navigation::Instruction>&& value);
  inline ::capnp::Orphan< ::cereal::StarPilotCarControl::Navigation::Instruction> disownInstruction();

  inline bool hasRoute();
  inline  ::capnp::List< ::cereal::StarPilotCarControl::Navigation::Coordinate,  ::capnp::Kind::STRUCT>::Builder getRoute();
  inline void setRoute( ::capnp::List< ::cereal::StarPilotCarControl::Navigation::Coordinate,  ::capnp::Kind::STRUCT>::Reader value);
  inline  ::capnp::List< ::cereal::StarPilotCarControl::Navigation::Coordinate,  ::capnp::Kind::STRUCT>::Builder initRoute(unsigned int size);
  inline void adoptRoute(::capnp::Orphan< ::capnp::List< ::cereal::StarPilotCarControl::Navigation::Coordinate,  ::capnp::Kind::STRUCT>>&& value);
  inline ::capnp::Orphan< ::capnp::List< ::cereal::StarPilotCarControl::Navigation::Coordinate,  ::capnp::Kind::STRUCT>> disownRoute();

  inline bool hasNextManeuver();
  inline  ::cereal::StarPilotCarControl::Navigation::Instruction::Builder getNextManeuver();
  inline void setNextManeuver( ::cereal::StarPilotCarControl::Navigation::Instruction::Reader value);
  inline  ::cereal::StarPilotCarControl::Navigation::Instruction::Builder initNextManeuver();
  inline void adoptNextManeuver(::capnp::Orphan< ::cereal::StarPilotCarControl::Navigation::Instruction>&& value);
  inline ::capnp::Orphan< ::cereal::StarPilotCarControl::Navigation::Instruction> disownNextManeuver();

  inline  ::uint64_t getLocationMonoTime();
  inline void setLocationMonoTime( ::uint64_t value);

  inline bool getControlValid();
  inline void setControlValid(bool value);

  inline  ::uint16_t getVersion();
  inline void setVersion( ::uint16_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 StarPilotCarControl::Navigation::Pipeline {
public:
  typedef Navigation Pipelines;

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

  inline  ::cereal::StarPilotCarControl::Navigation::Instruction::Pipeline getInstruction();
  inline  ::cereal::StarPilotCarControl::Navigation::Instruction::Pipeline getNextManeuver();
private:
  ::capnp::AnyPointer::Pipeline _typeless;
  friend class ::capnp::PipelineHook;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
};
#endif  // !CAPNP_LITE

class StarPilotCarControl::Navigation::Coordinate::Reader {
public:
  typedef Coordinate 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 double getLatitude() const;

  inline double getLongitude() 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 StarPilotCarControl::Navigation::Coordinate::Builder {
public:
  typedef Coordinate 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 double getLatitude();
  inline void setLatitude(double value);

  inline double getLongitude();
  inline void setLongitude(double 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 StarPilotCarControl::Navigation::Coordinate::Pipeline {
public:
  typedef Coordinate 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 StarPilotCarControl::Navigation::Instruction::Reader {
public:
  typedef Instruction 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 hasText() const;
  inline  ::capnp::Text::Reader getText() const;

  inline bool hasManeuverType() const;
  inline  ::capnp::Text::Reader getManeuverType() const;

  inline bool hasManeuverModifier() const;
  inline  ::capnp::Text::Reader getManeuverModifier() const;

  inline float getDistanceMeters() const;

  inline float getRemainingDistanceMeters() const;

  inline float getRemainingDurationSeconds() 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 StarPilotCarControl::Navigation::Instruction::Builder {
public:
  typedef Instruction 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 hasText();
  inline  ::capnp::Text::Builder getText();
  inline void setText( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initText(unsigned int size);
  inline void adoptText(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownText();

  inline bool hasManeuverType();
  inline  ::capnp::Text::Builder getManeuverType();
  inline void setManeuverType( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initManeuverType(unsigned int size);
  inline void adoptManeuverType(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownManeuverType();

  inline bool hasManeuverModifier();
  inline  ::capnp::Text::Builder getManeuverModifier();
  inline void setManeuverModifier( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initManeuverModifier(unsigned int size);
  inline void adoptManeuverModifier(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownManeuverModifier();

  inline float getDistanceMeters();
  inline void setDistanceMeters(float value);

  inline float getRemainingDistanceMeters();
  inline void setRemainingDistanceMeters(float value);

  inline float getRemainingDurationSeconds();
  inline void setRemainingDurationSeconds(float 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 StarPilotCarControl::Navigation::Instruction::Pipeline {
public:
  typedef Instruction 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 StarPilotCarControl::PreapRadarStartup::Reader {
public:
  typedef PreapRadarStartup 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  ::uint16_t getVersion() const;

  inline  ::uint16_t getKind() const;

  inline bool hasCarParamsSha256() const;
  inline  ::capnp::Data::Reader getCarParamsSha256() const;

  inline  ::uint16_t getSafetyModel() const;

  inline  ::uint16_t getSafetyParam() const;

  inline float getLateralOffset() 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 StarPilotCarControl::PreapRadarStartup::Builder {
public:
  typedef PreapRadarStartup 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  ::uint16_t getVersion();
  inline void setVersion( ::uint16_t value);

  inline  ::uint16_t getKind();
  inline void setKind( ::uint16_t value);

  inline bool hasCarParamsSha256();
  inline  ::capnp::Data::Builder getCarParamsSha256();
  inline void setCarParamsSha256( ::capnp::Data::Reader value);
  inline  ::capnp::Data::Builder initCarParamsSha256(unsigned int size);
  inline void adoptCarParamsSha256(::capnp::Orphan< ::capnp::Data>&& value);
  inline ::capnp::Orphan< ::capnp::Data> disownCarParamsSha256();

  inline  ::uint16_t getSafetyModel();
  inline void setSafetyModel( ::uint16_t value);

  inline  ::uint16_t getSafetyParam();
  inline void setSafetyParam( ::uint16_t value);

  inline float getLateralOffset();
  inline void setLateralOffset(float 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 StarPilotCarControl::PreapRadarStartup::Pipeline {
public:
  typedef PreapRadarStartup 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 StarPilotCarControl::PreapPedalStartup::Reader {
public:
  typedef PreapPedalStartup 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  ::uint16_t getVersion() const;

  inline  ::uint16_t getKind() const;

  inline bool hasCarParamsSha256() const;
  inline  ::capnp::Data::Reader getCarParamsSha256() const;

  inline  ::uint16_t getSafetyModel() const;

  inline  ::uint16_t getSafetyParam() const;

  inline float getFactor() const;

  inline float getZero() const;

  inline  ::uint16_t getPedalBus() const;

  inline  ::uint64_t getSourceMonoTime() 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 StarPilotCarControl::PreapPedalStartup::Builder {
public:
  typedef PreapPedalStartup 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  ::uint16_t getVersion();
  inline void setVersion( ::uint16_t value);

  inline  ::uint16_t getKind();
  inline void setKind( ::uint16_t value);

  inline bool hasCarParamsSha256();
  inline  ::capnp::Data::Builder getCarParamsSha256();
  inline void setCarParamsSha256( ::capnp::Data::Reader value);
  inline  ::capnp::Data::Builder initCarParamsSha256(unsigned int size);
  inline void adoptCarParamsSha256(::capnp::Orphan< ::capnp::Data>&& value);
  inline ::capnp::Orphan< ::capnp::Data> disownCarParamsSha256();

  inline  ::uint16_t getSafetyModel();
  inline void setSafetyModel( ::uint16_t value);

  inline  ::uint16_t getSafetyParam();
  inline void setSafetyParam( ::uint16_t value);

  inline float getFactor();
  inline void setFactor(float value);

  inline float getZero();
  inline void setZero(float value);

  inline  ::uint16_t getPedalBus();
  inline void setPedalBus( ::uint16_t value);

  inline  ::uint64_t getSourceMonoTime();
  inline void setSourceMonoTime( ::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 StarPilotCarControl::PreapPedalStartup::Pipeline {
public:
  typedef PreapPedalStartup 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 StarPilotCarParams::Reader {
public:
  typedef StarPilotCarParams 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  ::int16_t getAlternativeExperience() const;

  inline bool getCanUsePedal() const;

  inline bool getCanUseSDSU() const;

  inline  ::uint32_t getFlags() const;

  inline bool getIsHDA2() const;

  inline bool getOpenpilotLongitudinalControlDisabled() const;

  inline bool hasSafetyConfigs() const;
  inline  ::capnp::List< ::cereal::StarPilotCarParams::SafetyConfig,  ::capnp::Kind::STRUCT>::Reader getSafetyConfigs() const;

  inline bool getPcmCruiseSpeed() const;

  inline bool getRedneckCruiseAvailable() const;

  inline bool hasLearning() const;
  inline  ::cereal::StarPilotCarParams::AutoSteeringLearning::Reader getLearning() 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 StarPilotCarParams::Builder {
public:
  typedef StarPilotCarParams 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  ::int16_t getAlternativeExperience();
  inline void setAlternativeExperience( ::int16_t value);

  inline bool getCanUsePedal();
  inline void setCanUsePedal(bool value);

  inline bool getCanUseSDSU();
  inline void setCanUseSDSU(bool value);

  inline  ::uint32_t getFlags();
  inline void setFlags( ::uint32_t value);

  inline bool getIsHDA2();
  inline void setIsHDA2(bool value);

  inline bool getOpenpilotLongitudinalControlDisabled();
  inline void setOpenpilotLongitudinalControlDisabled(bool value);

  inline bool hasSafetyConfigs();
  inline  ::capnp::List< ::cereal::StarPilotCarParams::SafetyConfig,  ::capnp::Kind::STRUCT>::Builder getSafetyConfigs();
  inline void setSafetyConfigs( ::capnp::List< ::cereal::StarPilotCarParams::SafetyConfig,  ::capnp::Kind::STRUCT>::Reader value);
  inline  ::capnp::List< ::cereal::StarPilotCarParams::SafetyConfig,  ::capnp::Kind::STRUCT>::Builder initSafetyConfigs(unsigned int size);
  inline void adoptSafetyConfigs(::capnp::Orphan< ::capnp::List< ::cereal::StarPilotCarParams::SafetyConfig,  ::capnp::Kind::STRUCT>>&& value);
  inline ::capnp::Orphan< ::capnp::List< ::cereal::StarPilotCarParams::SafetyConfig,  ::capnp::Kind::STRUCT>> disownSafetyConfigs();

  inline bool getPcmCruiseSpeed();
  inline void setPcmCruiseSpeed(bool value);

  inline bool getRedneckCruiseAvailable();
  inline void setRedneckCruiseAvailable(bool value);

  inline bool hasLearning();
  inline  ::cereal::StarPilotCarParams::AutoSteeringLearning::Builder getLearning();
  inline void setLearning( ::cereal::StarPilotCarParams::AutoSteeringLearning::Reader value);
  inline  ::cereal::StarPilotCarParams::AutoSteeringLearning::Builder initLearning();
  inline void adoptLearning(::capnp::Orphan< ::cereal::StarPilotCarParams::AutoSteeringLearning>&& value);
  inline ::capnp::Orphan< ::cereal::StarPilotCarParams::AutoSteeringLearning> disownLearning();

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 StarPilotCarParams::Pipeline {
public:
  typedef StarPilotCarParams Pipelines;

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

  inline  ::cereal::StarPilotCarParams::AutoSteeringLearning::Pipeline getLearning();
private:
  ::capnp::AnyPointer::Pipeline _typeless;
  friend class ::capnp::PipelineHook;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
};
#endif  // !CAPNP_LITE

class StarPilotCarParams::SafetyConfig::Reader {
public:
  typedef SafetyConfig 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  ::uint16_t getSafetyParam() 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 StarPilotCarParams::SafetyConfig::Builder {
public:
  typedef SafetyConfig 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  ::uint16_t getSafetyParam();
  inline void setSafetyParam( ::uint16_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 StarPilotCarParams::SafetyConfig::Pipeline {
public:
  typedef SafetyConfig 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 StarPilotCarParams::AutoSteeringLearning::Reader {
public:
  typedef AutoSteeringLearning 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  ::uint16_t getVersion() const;

  inline  ::cereal::StarPilotCarParams::AutoSteeringLearning::Status getStatus() const;

  inline bool hasReason() const;
  inline  ::capnp::Text::Reader getReason() const;

  inline bool hasIdentity() const;
  inline  ::cereal::StarPilotCarParams::AutoSteeringLearning::Identity::Reader getIdentity() const;

  inline bool hasSession() const;
  inline  ::capnp::Text::Reader getSession() const;

  inline  ::uint64_t getSequence() const;

  inline  ::uint64_t getObservedMonoTime() const;

  inline  ::uint64_t getValidUntilMonoTime() const;

  inline  ::uint64_t getSourceWindowStartMonoTime() const;

  inline  ::uint64_t getSourceWindowEndMonoTime() const;

  inline  ::cereal::StarPilotCarParams::AutoSteeringLearning::Family getFamily() const;

  inline double getLatAccelFactor() const;

  inline bool hasAcceptancePolicyId() const;
  inline  ::capnp::Text::Reader getAcceptancePolicyId() const;

  inline  ::uint32_t getTrainWindows() const;

  inline  ::uint32_t getHeldoutWindows() const;

  inline double getTrainBaselineLoss() const;

  inline double getTrainCandidateLoss() const;

  inline double getHeldoutBaselineLoss() const;

  inline double getHeldoutCandidateLoss() const;

  inline bool hasRuntimeProfile() const;
  inline  ::cereal::AutomaticRuntimeProfile::Reader getRuntimeProfile() const;

  inline bool hasSourceReceipt() const;
  inline  ::cereal::AutomaticLearningSourceReceipt::Reader getSourceReceipt() const;

  inline bool hasCentreApplicationWitness() const;
  inline  ::cereal::CentreApplicationWitness::Reader getCentreApplicationWitness() 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 StarPilotCarParams::AutoSteeringLearning::Builder {
public:
  typedef AutoSteeringLearning 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  ::uint16_t getVersion();
  inline void setVersion( ::uint16_t value);

  inline  ::cereal::StarPilotCarParams::AutoSteeringLearning::Status getStatus();
  inline void setStatus( ::cereal::StarPilotCarParams::AutoSteeringLearning::Status value);

  inline bool hasReason();
  inline  ::capnp::Text::Builder getReason();
  inline void setReason( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initReason(unsigned int size);
  inline void adoptReason(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownReason();

  inline bool hasIdentity();
  inline  ::cereal::StarPilotCarParams::AutoSteeringLearning::Identity::Builder getIdentity();
  inline void setIdentity( ::cereal::StarPilotCarParams::AutoSteeringLearning::Identity::Reader value);
  inline  ::cereal::StarPilotCarParams::AutoSteeringLearning::Identity::Builder initIdentity();
  inline void adoptIdentity(::capnp::Orphan< ::cereal::StarPilotCarParams::AutoSteeringLearning::Identity>&& value);
  inline ::capnp::Orphan< ::cereal::StarPilotCarParams::AutoSteeringLearning::Identity> disownIdentity();

  inline bool hasSession();
  inline  ::capnp::Text::Builder getSession();
  inline void setSession( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initSession(unsigned int size);
  inline void adoptSession(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownSession();

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

  inline  ::uint64_t getObservedMonoTime();
  inline void setObservedMonoTime( ::uint64_t value);

  inline  ::uint64_t getValidUntilMonoTime();
  inline void setValidUntilMonoTime( ::uint64_t value);

  inline  ::uint64_t getSourceWindowStartMonoTime();
  inline void setSourceWindowStartMonoTime( ::uint64_t value);

  inline  ::uint64_t getSourceWindowEndMonoTime();
  inline void setSourceWindowEndMonoTime( ::uint64_t value);

  inline  ::cereal::StarPilotCarParams::AutoSteeringLearning::Family getFamily();
  inline void setFamily( ::cereal::StarPilotCarParams::AutoSteeringLearning::Family value);

  inline double getLatAccelFactor();
  inline void setLatAccelFactor(double value);

  inline bool hasAcceptancePolicyId();
  inline  ::capnp::Text::Builder getAcceptancePolicyId();
  inline void setAcceptancePolicyId( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initAcceptancePolicyId(unsigned int size);
  inline void adoptAcceptancePolicyId(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownAcceptancePolicyId();

  inline  ::uint32_t getTrainWindows();
  inline void setTrainWindows( ::uint32_t value);

  inline  ::uint32_t getHeldoutWindows();
  inline void setHeldoutWindows( ::uint32_t value);

  inline double getTrainBaselineLoss();
  inline void setTrainBaselineLoss(double value);

  inline double getTrainCandidateLoss();
  inline void setTrainCandidateLoss(double value);

  inline double getHeldoutBaselineLoss();
  inline void setHeldoutBaselineLoss(double value);

  inline double getHeldoutCandidateLoss();
  inline void setHeldoutCandidateLoss(double value);

  inline bool hasRuntimeProfile();
  inline  ::cereal::AutomaticRuntimeProfile::Builder getRuntimeProfile();
  inline void setRuntimeProfile( ::cereal::AutomaticRuntimeProfile::Reader value);
  inline  ::cereal::AutomaticRuntimeProfile::Builder initRuntimeProfile();
  inline void adoptRuntimeProfile(::capnp::Orphan< ::cereal::AutomaticRuntimeProfile>&& value);
  inline ::capnp::Orphan< ::cereal::AutomaticRuntimeProfile> disownRuntimeProfile();

  inline bool hasSourceReceipt();
  inline  ::cereal::AutomaticLearningSourceReceipt::Builder getSourceReceipt();
  inline void setSourceReceipt( ::cereal::AutomaticLearningSourceReceipt::Reader value);
  inline  ::cereal::AutomaticLearningSourceReceipt::Builder initSourceReceipt();
  inline void adoptSourceReceipt(::capnp::Orphan< ::cereal::AutomaticLearningSourceReceipt>&& value);
  inline ::capnp::Orphan< ::cereal::AutomaticLearningSourceReceipt> disownSourceReceipt();

  inline bool hasCentreApplicationWitness();
  inline  ::cereal::CentreApplicationWitness::Builder getCentreApplicationWitness();
  inline void setCentreApplicationWitness( ::cereal::CentreApplicationWitness::Reader value);
  inline  ::cereal::CentreApplicationWitness::Builder initCentreApplicationWitness();
  inline void adoptCentreApplicationWitness(::capnp::Orphan< ::cereal::CentreApplicationWitness>&& value);
  inline ::capnp::Orphan< ::cereal::CentreApplicationWitness> disownCentreApplicationWitness();

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 StarPilotCarParams::AutoSteeringLearning::Pipeline {
public:
  typedef AutoSteeringLearning Pipelines;

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

  inline  ::cereal::StarPilotCarParams::AutoSteeringLearning::Identity::Pipeline getIdentity();
  inline  ::cereal::AutomaticRuntimeProfile::Pipeline getRuntimeProfile();
  inline  ::cereal::AutomaticLearningSourceReceipt::Pipeline getSourceReceipt();
  inline  ::cereal::CentreApplicationWitness::Pipeline getCentreApplicationWitness();
private:
  ::capnp::AnyPointer::Pipeline _typeless;
  friend class ::capnp::PipelineHook;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
};
#endif  // !CAPNP_LITE

class StarPilotCarParams::AutoSteeringLearning::Identity::Reader {
public:
  typedef Identity 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 hasVehicle() const;
  inline  ::capnp::Text::Reader getVehicle() const;

  inline bool hasBrand() const;
  inline  ::capnp::Text::Reader getBrand() const;

  inline bool hasController() const;
  inline  ::capnp::Text::Reader getController() const;

  inline bool hasPolicy() const;
  inline  ::capnp::Text::Reader getPolicy() const;

  inline bool hasProfile() const;
  inline  ::capnp::Text::Reader getProfile() const;

  inline bool hasConversionVersion() const;
  inline  ::capnp::Text::Reader getConversionVersion() const;

  inline bool hasFirmwareSha256() const;
  inline  ::capnp::Text::Reader getFirmwareSha256() const;

  inline bool hasBasis() const;
  inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Reader getBasis() const;

  inline bool hasBaselineSha256() const;
  inline  ::capnp::Text::Reader getBaselineSha256() const;

  inline bool hasPreferenceSha256() const;
  inline  ::capnp::Text::Reader getPreferenceSha256() const;

  inline bool hasResetGeneration() const;
  inline  ::capnp::Text::Reader getResetGeneration() const;

  inline bool hasControllerRevision() const;
  inline  ::capnp::Text::Reader getControllerRevision() 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 StarPilotCarParams::AutoSteeringLearning::Identity::Builder {
public:
  typedef Identity 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 hasVehicle();
  inline  ::capnp::Text::Builder getVehicle();
  inline void setVehicle( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initVehicle(unsigned int size);
  inline void adoptVehicle(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownVehicle();

  inline bool hasBrand();
  inline  ::capnp::Text::Builder getBrand();
  inline void setBrand( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initBrand(unsigned int size);
  inline void adoptBrand(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownBrand();

  inline bool hasController();
  inline  ::capnp::Text::Builder getController();
  inline void setController( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initController(unsigned int size);
  inline void adoptController(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownController();

  inline bool hasPolicy();
  inline  ::capnp::Text::Builder getPolicy();
  inline void setPolicy( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initPolicy(unsigned int size);
  inline void adoptPolicy(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownPolicy();

  inline bool hasProfile();
  inline  ::capnp::Text::Builder getProfile();
  inline void setProfile( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initProfile(unsigned int size);
  inline void adoptProfile(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownProfile();

  inline bool hasConversionVersion();
  inline  ::capnp::Text::Builder getConversionVersion();
  inline void setConversionVersion( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initConversionVersion(unsigned int size);
  inline void adoptConversionVersion(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownConversionVersion();

  inline bool hasFirmwareSha256();
  inline  ::capnp::Text::Builder getFirmwareSha256();
  inline void setFirmwareSha256( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initFirmwareSha256(unsigned int size);
  inline void adoptFirmwareSha256(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownFirmwareSha256();

  inline bool hasBasis();
  inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Builder getBasis();
  inline void setBasis( ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Reader value);
  inline void setBasis(::kj::ArrayPtr<const double> value);
  inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Builder initBasis(unsigned int size);
  inline void adoptBasis(::capnp::Orphan< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>&& value);
  inline ::capnp::Orphan< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>> disownBasis();

  inline bool hasBaselineSha256();
  inline  ::capnp::Text::Builder getBaselineSha256();
  inline void setBaselineSha256( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initBaselineSha256(unsigned int size);
  inline void adoptBaselineSha256(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownBaselineSha256();

  inline bool hasPreferenceSha256();
  inline  ::capnp::Text::Builder getPreferenceSha256();
  inline void setPreferenceSha256( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initPreferenceSha256(unsigned int size);
  inline void adoptPreferenceSha256(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownPreferenceSha256();

  inline bool hasResetGeneration();
  inline  ::capnp::Text::Builder getResetGeneration();
  inline void setResetGeneration( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initResetGeneration(unsigned int size);
  inline void adoptResetGeneration(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownResetGeneration();

  inline bool hasControllerRevision();
  inline  ::capnp::Text::Builder getControllerRevision();
  inline void setControllerRevision( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initControllerRevision(unsigned int size);
  inline void adoptControllerRevision(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownControllerRevision();

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 StarPilotCarParams::AutoSteeringLearning::Identity::Pipeline {
public:
  typedef Identity 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 StarPilotCarState::Reader {
public:
  typedef StarPilotCarState 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 getAccelPressed() const;

  inline bool getAlwaysOnLateralEnabled() const;

  inline bool getBrakeLights() const;

  inline float getDashboardSpeedLimit() const;

  inline bool getDecelPressed() const;

  inline bool getDistancePressed() const;

  inline bool getDistanceLongPressed() const;

  inline bool getDistanceVeryLongPressed() const;

  inline bool getEcoGear() const;

  inline bool getForceCoast() const;

  inline bool getIsParked() const;

  inline bool getPauseLateral() const;

  inline bool getPauseLongitudinal() const;

  inline bool getSportGear() const;

  inline bool getTrafficModeEnabled() const;

  inline bool getGasStack() const;

  inline bool getModePressed() const;

  inline bool getCustomPressed() const;

  inline bool getAlwaysOnLateralAllowed() const;

  inline  ::uint8_t getDashboardStopSign() const;

  inline bool getCancelPressed() const;

  inline bool getCancelLongPressed() const;

  inline bool getCancelVeryLongPressed() const;

  inline bool getPedalMaxRegen() const;

  inline bool getPedalLongActive() const;

  inline bool getTeslaCCEngaged() const;

  inline bool getTeslaCCDisengaged() const;

  inline bool getTeslaCCNotArmed() const;

  inline bool getAccelHardCruise() const;

  inline bool getDecelHardCruise() const;

  inline bool getPulseAndGlide() const;

  inline bool hasGps() const;
  inline  ::cereal::StarPilotCarState::Gps::Reader getGps() const;

  inline bool getLateralAuthorityUnavailable() const;

  inline  ::uint64_t getSourceCarStateMonoTime() const;

  inline bool hasAppliedEvidence() const;
  inline  ::cereal::LearningAppliedEvidence::Reader getAppliedEvidence() const;

  inline bool hasFordLearningEvidence() const;
  inline  ::cereal::FordLearningEvidence::Reader getFordLearningEvidence() const;

  inline bool hasLearningApplication() const;
  inline  ::cereal::LearningApplication::Reader getLearningApplication() const;

  inline bool hasFeedbackPublication() const;
  inline  ::cereal::StarPilotCarState::FeedbackPublication::Reader getFeedbackPublication() 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 StarPilotCarState::Builder {
public:
  typedef StarPilotCarState 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 getAccelPressed();
  inline void setAccelPressed(bool value);

  inline bool getAlwaysOnLateralEnabled();
  inline void setAlwaysOnLateralEnabled(bool value);

  inline bool getBrakeLights();
  inline void setBrakeLights(bool value);

  inline float getDashboardSpeedLimit();
  inline void setDashboardSpeedLimit(float value);

  inline bool getDecelPressed();
  inline void setDecelPressed(bool value);

  inline bool getDistancePressed();
  inline void setDistancePressed(bool value);

  inline bool getDistanceLongPressed();
  inline void setDistanceLongPressed(bool value);

  inline bool getDistanceVeryLongPressed();
  inline void setDistanceVeryLongPressed(bool value);

  inline bool getEcoGear();
  inline void setEcoGear(bool value);

  inline bool getForceCoast();
  inline void setForceCoast(bool value);

  inline bool getIsParked();
  inline void setIsParked(bool value);

  inline bool getPauseLateral();
  inline void setPauseLateral(bool value);

  inline bool getPauseLongitudinal();
  inline void setPauseLongitudinal(bool value);

  inline bool getSportGear();
  inline void setSportGear(bool value);

  inline bool getTrafficModeEnabled();
  inline void setTrafficModeEnabled(bool value);

  inline bool getGasStack();
  inline void setGasStack(bool value);

  inline bool getModePressed();
  inline void setModePressed(bool value);

  inline bool getCustomPressed();
  inline void setCustomPressed(bool value);

  inline bool getAlwaysOnLateralAllowed();
  inline void setAlwaysOnLateralAllowed(bool value);

  inline  ::uint8_t getDashboardStopSign();
  inline void setDashboardStopSign( ::uint8_t value);

  inline bool getCancelPressed();
  inline void setCancelPressed(bool value);

  inline bool getCancelLongPressed();
  inline void setCancelLongPressed(bool value);

  inline bool getCancelVeryLongPressed();
  inline void setCancelVeryLongPressed(bool value);

  inline bool getPedalMaxRegen();
  inline void setPedalMaxRegen(bool value);

  inline bool getPedalLongActive();
  inline void setPedalLongActive(bool value);

  inline bool getTeslaCCEngaged();
  inline void setTeslaCCEngaged(bool value);

  inline bool getTeslaCCDisengaged();
  inline void setTeslaCCDisengaged(bool value);

  inline bool getTeslaCCNotArmed();
  inline void setTeslaCCNotArmed(bool value);

  inline bool getAccelHardCruise();
  inline void setAccelHardCruise(bool value);

  inline bool getDecelHardCruise();
  inline void setDecelHardCruise(bool value);

  inline bool getPulseAndGlide();
  inline void setPulseAndGlide(bool value);

  inline bool hasGps();
  inline  ::cereal::StarPilotCarState::Gps::Builder getGps();
  inline void setGps( ::cereal::StarPilotCarState::Gps::Reader value);
  inline  ::cereal::StarPilotCarState::Gps::Builder initGps();
  inline void adoptGps(::capnp::Orphan< ::cereal::StarPilotCarState::Gps>&& value);
  inline ::capnp::Orphan< ::cereal::StarPilotCarState::Gps> disownGps();

  inline bool getLateralAuthorityUnavailable();
  inline void setLateralAuthorityUnavailable(bool value);

  inline  ::uint64_t getSourceCarStateMonoTime();
  inline void setSourceCarStateMonoTime( ::uint64_t value);

  inline bool hasAppliedEvidence();
  inline  ::cereal::LearningAppliedEvidence::Builder getAppliedEvidence();
  inline void setAppliedEvidence( ::cereal::LearningAppliedEvidence::Reader value);
  inline  ::cereal::LearningAppliedEvidence::Builder initAppliedEvidence();
  inline void adoptAppliedEvidence(::capnp::Orphan< ::cereal::LearningAppliedEvidence>&& value);
  inline ::capnp::Orphan< ::cereal::LearningAppliedEvidence> disownAppliedEvidence();

  inline bool hasFordLearningEvidence();
  inline  ::cereal::FordLearningEvidence::Builder getFordLearningEvidence();
  inline void setFordLearningEvidence( ::cereal::FordLearningEvidence::Reader value);
  inline  ::cereal::FordLearningEvidence::Builder initFordLearningEvidence();
  inline void adoptFordLearningEvidence(::capnp::Orphan< ::cereal::FordLearningEvidence>&& value);
  inline ::capnp::Orphan< ::cereal::FordLearningEvidence> disownFordLearningEvidence();

  inline bool hasLearningApplication();
  inline  ::cereal::LearningApplication::Builder getLearningApplication();
  inline void setLearningApplication( ::cereal::LearningApplication::Reader value);
  inline  ::cereal::LearningApplication::Builder initLearningApplication();
  inline void adoptLearningApplication(::capnp::Orphan< ::cereal::LearningApplication>&& value);
  inline ::capnp::Orphan< ::cereal::LearningApplication> disownLearningApplication();

  inline bool hasFeedbackPublication();
  inline  ::cereal::StarPilotCarState::FeedbackPublication::Builder getFeedbackPublication();
  inline void setFeedbackPublication( ::cereal::StarPilotCarState::FeedbackPublication::Reader value);
  inline  ::cereal::StarPilotCarState::FeedbackPublication::Builder initFeedbackPublication();
  inline void adoptFeedbackPublication(::capnp::Orphan< ::cereal::StarPilotCarState::FeedbackPublication>&& value);
  inline ::capnp::Orphan< ::cereal::StarPilotCarState::FeedbackPublication> disownFeedbackPublication();

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 StarPilotCarState::Pipeline {
public:
  typedef StarPilotCarState Pipelines;

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

  inline  ::cereal::StarPilotCarState::Gps::Pipeline getGps();
  inline  ::cereal::LearningAppliedEvidence::Pipeline getAppliedEvidence();
  inline  ::cereal::FordLearningEvidence::Pipeline getFordLearningEvidence();
  inline  ::cereal::LearningApplication::Pipeline getLearningApplication();
  inline  ::cereal::StarPilotCarState::FeedbackPublication::Pipeline getFeedbackPublication();
private:
  ::capnp::AnyPointer::Pipeline _typeless;
  friend class ::capnp::PipelineHook;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
};
#endif  // !CAPNP_LITE

class StarPilotCarState::Gps::Reader {
public:
  typedef Gps 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  ::uint64_t getSourceMonoTime() const;

  inline double getLatitude() const;

  inline double getLongitude() const;

  inline double getAltitude() const;

  inline float getSpeed() const;

  inline float getBearingDeg() const;

  inline float getHorizontalAccuracy() const;

  inline float getVerticalAccuracy() const;

  inline float getBearingAccuracyDeg() const;

  inline float getSpeedAccuracy() const;

  inline  ::int64_t getUnixTimestampMillis() const;

  inline bool getHasFix() const;

  inline bool hasVNED() const;
  inline  ::capnp::List<float,  ::capnp::Kind::PRIMITIVE>::Reader getVNED() 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 StarPilotCarState::Gps::Builder {
public:
  typedef Gps 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  ::uint64_t getSourceMonoTime();
  inline void setSourceMonoTime( ::uint64_t value);

  inline double getLatitude();
  inline void setLatitude(double value);

  inline double getLongitude();
  inline void setLongitude(double value);

  inline double getAltitude();
  inline void setAltitude(double value);

  inline float getSpeed();
  inline void setSpeed(float value);

  inline float getBearingDeg();
  inline void setBearingDeg(float value);

  inline float getHorizontalAccuracy();
  inline void setHorizontalAccuracy(float value);

  inline float getVerticalAccuracy();
  inline void setVerticalAccuracy(float value);

  inline float getBearingAccuracyDeg();
  inline void setBearingAccuracyDeg(float value);

  inline float getSpeedAccuracy();
  inline void setSpeedAccuracy(float value);

  inline  ::int64_t getUnixTimestampMillis();
  inline void setUnixTimestampMillis( ::int64_t value);

  inline bool getHasFix();
  inline void setHasFix(bool value);

  inline bool hasVNED();
  inline  ::capnp::List<float,  ::capnp::Kind::PRIMITIVE>::Builder getVNED();
  inline void setVNED( ::capnp::List<float,  ::capnp::Kind::PRIMITIVE>::Reader value);
  inline void setVNED(::kj::ArrayPtr<const float> value);
  inline  ::capnp::List<float,  ::capnp::Kind::PRIMITIVE>::Builder initVNED(unsigned int size);
  inline void adoptVNED(::capnp::Orphan< ::capnp::List<float,  ::capnp::Kind::PRIMITIVE>>&& value);
  inline ::capnp::Orphan< ::capnp::List<float,  ::capnp::Kind::PRIMITIVE>> disownVNED();

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 StarPilotCarState::Gps::Pipeline {
public:
  typedef Gps 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 StarPilotCarState::FeedbackPublication::Reader {
public:
  typedef FeedbackPublication 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  ::uint16_t getVersion() const;

  inline bool hasCardSession() const;
  inline  ::capnp::Data::Reader getCardSession() const;

  inline  ::uint64_t getPublicationSequence() const;

  inline  ::uint64_t getPublicationMonoTime() const;

  inline  ::uint64_t getSourceCarStateMonoTime() const;

  inline bool getOutputKnown() const;

  inline  ::uint64_t getOutputControlMonoTime() const;

  inline  ::uint64_t getOutputApplyMonoTime() const;

  inline bool hasOutputNativeIdentity() const;
  inline  ::capnp::Text::Reader getOutputNativeIdentity() const;

  inline  ::uint64_t getOutputCarrierSequence() const;

  inline float getReportedTorque() const;

  inline bool getOutputValid() const;

  inline bool hasCoBodySha256() const;
  inline  ::capnp::Data::Reader getCoBodySha256() const;

  inline bool hasApplyEvidenceSha256() const;
  inline  ::capnp::Data::Reader getApplyEvidenceSha256() const;

  inline bool hasSourceEpoch() const;
  inline  ::capnp::Text::Reader getSourceEpoch() const;

  inline bool hasCpSha256() const;
  inline  ::capnp::Text::Reader getCpSha256() const;

  inline  ::uint64_t getCarrierObservedMonoTime() 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 StarPilotCarState::FeedbackPublication::Builder {
public:
  typedef FeedbackPublication 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  ::uint16_t getVersion();
  inline void setVersion( ::uint16_t value);

  inline bool hasCardSession();
  inline  ::capnp::Data::Builder getCardSession();
  inline void setCardSession( ::capnp::Data::Reader value);
  inline  ::capnp::Data::Builder initCardSession(unsigned int size);
  inline void adoptCardSession(::capnp::Orphan< ::capnp::Data>&& value);
  inline ::capnp::Orphan< ::capnp::Data> disownCardSession();

  inline  ::uint64_t getPublicationSequence();
  inline void setPublicationSequence( ::uint64_t value);

  inline  ::uint64_t getPublicationMonoTime();
  inline void setPublicationMonoTime( ::uint64_t value);

  inline  ::uint64_t getSourceCarStateMonoTime();
  inline void setSourceCarStateMonoTime( ::uint64_t value);

  inline bool getOutputKnown();
  inline void setOutputKnown(bool value);

  inline  ::uint64_t getOutputControlMonoTime();
  inline void setOutputControlMonoTime( ::uint64_t value);

  inline  ::uint64_t getOutputApplyMonoTime();
  inline void setOutputApplyMonoTime( ::uint64_t value);

  inline bool hasOutputNativeIdentity();
  inline  ::capnp::Text::Builder getOutputNativeIdentity();
  inline void setOutputNativeIdentity( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initOutputNativeIdentity(unsigned int size);
  inline void adoptOutputNativeIdentity(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownOutputNativeIdentity();

  inline  ::uint64_t getOutputCarrierSequence();
  inline void setOutputCarrierSequence( ::uint64_t value);

  inline float getReportedTorque();
  inline void setReportedTorque(float value);

  inline bool getOutputValid();
  inline void setOutputValid(bool value);

  inline bool hasCoBodySha256();
  inline  ::capnp::Data::Builder getCoBodySha256();
  inline void setCoBodySha256( ::capnp::Data::Reader value);
  inline  ::capnp::Data::Builder initCoBodySha256(unsigned int size);
  inline void adoptCoBodySha256(::capnp::Orphan< ::capnp::Data>&& value);
  inline ::capnp::Orphan< ::capnp::Data> disownCoBodySha256();

  inline bool hasApplyEvidenceSha256();
  inline  ::capnp::Data::Builder getApplyEvidenceSha256();
  inline void setApplyEvidenceSha256( ::capnp::Data::Reader value);
  inline  ::capnp::Data::Builder initApplyEvidenceSha256(unsigned int size);
  inline void adoptApplyEvidenceSha256(::capnp::Orphan< ::capnp::Data>&& value);
  inline ::capnp::Orphan< ::capnp::Data> disownApplyEvidenceSha256();

  inline bool hasSourceEpoch();
  inline  ::capnp::Text::Builder getSourceEpoch();
  inline void setSourceEpoch( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initSourceEpoch(unsigned int size);
  inline void adoptSourceEpoch(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownSourceEpoch();

  inline bool hasCpSha256();
  inline  ::capnp::Text::Builder getCpSha256();
  inline void setCpSha256( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initCpSha256(unsigned int size);
  inline void adoptCpSha256(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownCpSha256();

  inline  ::uint64_t getCarrierObservedMonoTime();
  inline void setCarrierObservedMonoTime( ::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 StarPilotCarState::FeedbackPublication::Pipeline {
public:
  typedef FeedbackPublication 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 StarPilotLongitudinalPlan::Reader {
public:
  typedef StarPilotLongitudinalPlan 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  ::uint16_t getVersion() const;

  inline  ::uint64_t getSourcePlanMonoTime() const;

  inline  ::uint64_t getModelMonoTime() const;

  inline  ::uint64_t getDriveStartMonoTime() const;

  inline bool getForceStopHolding() 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 StarPilotLongitudinalPlan::Builder {
public:
  typedef StarPilotLongitudinalPlan 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  ::uint16_t getVersion();
  inline void setVersion( ::uint16_t value);

  inline  ::uint64_t getSourcePlanMonoTime();
  inline void setSourcePlanMonoTime( ::uint64_t value);

  inline  ::uint64_t getModelMonoTime();
  inline void setModelMonoTime( ::uint64_t value);

  inline  ::uint64_t getDriveStartMonoTime();
  inline void setDriveStartMonoTime( ::uint64_t value);

  inline bool getForceStopHolding();
  inline void setForceStopHolding(bool 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 StarPilotLongitudinalPlan::Pipeline {
public:
  typedef StarPilotLongitudinalPlan 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 SlcState::Reader {
public:
  typedef SlcState 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 hasSlotId() const;
  inline  ::capnp::Text::Reader getSlotId() const;

  inline bool hasSlotName() const;
  inline  ::capnp::Text::Reader getSlotName() const;

  inline bool hasVariant() const;
  inline  ::capnp::Text::Reader getVariant() const;

  inline bool hasVariantLabel() const;
  inline  ::capnp::Text::Reader getVariantLabel() const;

  inline bool hasReason() const;
  inline  ::capnp::Text::Reader getReason() const;

  inline  ::uint64_t getWallTimeNanos() const;

  inline bool hasSessionId() const;
  inline  ::capnp::Text::Reader getSessionId() const;

  inline  ::uint64_t getFrameMonoTime() const;

  inline bool getEnabled() const;

  inline bool getDisplayOnly() const;

  inline bool hasObservationKind() const;
  inline  ::capnp::Text::Reader getObservationKind() const;

  inline bool hasSource() const;
  inline  ::capnp::Text::Reader getSource() const;

  inline float getSpeedLimit() const;

  inline float getAcceptedSpeedLimit() const;

  inline bool getHasAccepted() const;

  inline float getOffset() const;

  inline float getEffectiveCap() const;

  inline bool getHasCeiling() const;

  inline float getPendingSpeedLimit() const;

  inline bool getHasPending() const;

  inline  ::uint64_t getDecisionId() const;

  inline  ::uint64_t getPresentationId() const;

  inline bool hasStatus() const;
  inline  ::capnp::Text::Reader getStatus() const;

  inline  ::uint64_t getActionSequenceId() const;

  inline bool hasActionStatus() const;
  inline  ::capnp::Text::Reader getActionStatus() const;

  inline bool hasSourceProducerSessionId() const;
  inline  ::capnp::Text::Reader getSourceProducerSessionId() const;

  inline  ::uint32_t getSourceEpisode() const;

  inline  ::uint64_t getSourceObservedMonoTime() const;

  inline  ::uint64_t getSourceValidUntilMonoTime() const;

  inline  ::uint64_t getCommandId() const;

  inline bool hasCommandStatus() const;
  inline  ::capnp::Text::Reader getCommandStatus() const;

  inline bool hasCurve() const;
  inline  ::cereal::SlcState::CurveState::Reader getCurve() const;

  inline bool hasConditionalMode() const;
  inline  ::cereal::SlcState::ConditionalModeState::Reader getConditionalMode() const;

  inline bool hasTrafficMode() const;
  inline  ::cereal::SlcState::TrafficModeState::Reader getTrafficMode() const;

  inline bool hasSwitchbackMode() const;
  inline  ::cereal::SlcState::SwitchbackModeState::Reader getSwitchbackMode() const;

  inline bool hasAcceptedSource() const;
  inline  ::capnp::Text::Reader getAcceptedSource() const;

  inline bool hasPendingSource() const;
  inline  ::capnp::Text::Reader getPendingSource() const;

  inline float getEffectiveClusterTarget() const;

  inline bool getHasEffectiveClusterTarget() const;

  inline bool getIsLimitingMaxSet() const;

  inline bool getDriverOverrideActive() const;

  inline bool hasSourceReadings() const;
  inline  ::capnp::List< ::cereal::SlcState::SourceReading,  ::capnp::Kind::STRUCT>::Reader getSourceReadings() const;

  inline float getAcceptedAdjustedLimit() const;

  inline bool getHasAcceptedAdjustedLimit() const;

  inline float getPendingAdjustedLimit() const;

  inline bool getHasPendingAdjustedLimit() const;

  inline float getPresentationAdjustedLimit() const;

  inline bool getHasPresentationAdjustedLimit() const;

  inline bool hasOverrideBasis() const;
  inline  ::capnp::Text::Reader getOverrideBasis() const;

  inline bool getRetainedOverride() const;

  inline  ::uint64_t getCommandActionSequenceId() const;

  inline bool getAutomaticAdoptionPending() const;

  inline  ::uint64_t getPendingSinceMonoTime() const;

  inline float getLastReceivedSpeedLimit() const;

  inline bool hasLastReceivedSource() const;
  inline  ::capnp::Text::Reader getLastReceivedSource() const;

  inline float getLastReceivedAdjustedLimit() 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 SlcState::Builder {
public:
  typedef SlcState 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 hasSlotId();
  inline  ::capnp::Text::Builder getSlotId();
  inline void setSlotId( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initSlotId(unsigned int size);
  inline void adoptSlotId(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownSlotId();

  inline bool hasSlotName();
  inline  ::capnp::Text::Builder getSlotName();
  inline void setSlotName( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initSlotName(unsigned int size);
  inline void adoptSlotName(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownSlotName();

  inline bool hasVariant();
  inline  ::capnp::Text::Builder getVariant();
  inline void setVariant( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initVariant(unsigned int size);
  inline void adoptVariant(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownVariant();

  inline bool hasVariantLabel();
  inline  ::capnp::Text::Builder getVariantLabel();
  inline void setVariantLabel( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initVariantLabel(unsigned int size);
  inline void adoptVariantLabel(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownVariantLabel();

  inline bool hasReason();
  inline  ::capnp::Text::Builder getReason();
  inline void setReason( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initReason(unsigned int size);
  inline void adoptReason(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownReason();

  inline  ::uint64_t getWallTimeNanos();
  inline void setWallTimeNanos( ::uint64_t value);

  inline bool hasSessionId();
  inline  ::capnp::Text::Builder getSessionId();
  inline void setSessionId( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initSessionId(unsigned int size);
  inline void adoptSessionId(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownSessionId();

  inline  ::uint64_t getFrameMonoTime();
  inline void setFrameMonoTime( ::uint64_t value);

  inline bool getEnabled();
  inline void setEnabled(bool value);

  inline bool getDisplayOnly();
  inline void setDisplayOnly(bool value);

  inline bool hasObservationKind();
  inline  ::capnp::Text::Builder getObservationKind();
  inline void setObservationKind( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initObservationKind(unsigned int size);
  inline void adoptObservationKind(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownObservationKind();

  inline bool hasSource();
  inline  ::capnp::Text::Builder getSource();
  inline void setSource( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initSource(unsigned int size);
  inline void adoptSource(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownSource();

  inline float getSpeedLimit();
  inline void setSpeedLimit(float value);

  inline float getAcceptedSpeedLimit();
  inline void setAcceptedSpeedLimit(float value);

  inline bool getHasAccepted();
  inline void setHasAccepted(bool value);

  inline float getOffset();
  inline void setOffset(float value);

  inline float getEffectiveCap();
  inline void setEffectiveCap(float value);

  inline bool getHasCeiling();
  inline void setHasCeiling(bool value);

  inline float getPendingSpeedLimit();
  inline void setPendingSpeedLimit(float value);

  inline bool getHasPending();
  inline void setHasPending(bool value);

  inline  ::uint64_t getDecisionId();
  inline void setDecisionId( ::uint64_t value);

  inline  ::uint64_t getPresentationId();
  inline void setPresentationId( ::uint64_t value);

  inline bool hasStatus();
  inline  ::capnp::Text::Builder getStatus();
  inline void setStatus( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initStatus(unsigned int size);
  inline void adoptStatus(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownStatus();

  inline  ::uint64_t getActionSequenceId();
  inline void setActionSequenceId( ::uint64_t value);

  inline bool hasActionStatus();
  inline  ::capnp::Text::Builder getActionStatus();
  inline void setActionStatus( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initActionStatus(unsigned int size);
  inline void adoptActionStatus(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownActionStatus();

  inline bool hasSourceProducerSessionId();
  inline  ::capnp::Text::Builder getSourceProducerSessionId();
  inline void setSourceProducerSessionId( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initSourceProducerSessionId(unsigned int size);
  inline void adoptSourceProducerSessionId(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownSourceProducerSessionId();

  inline  ::uint32_t getSourceEpisode();
  inline void setSourceEpisode( ::uint32_t value);

  inline  ::uint64_t getSourceObservedMonoTime();
  inline void setSourceObservedMonoTime( ::uint64_t value);

  inline  ::uint64_t getSourceValidUntilMonoTime();
  inline void setSourceValidUntilMonoTime( ::uint64_t value);

  inline  ::uint64_t getCommandId();
  inline void setCommandId( ::uint64_t value);

  inline bool hasCommandStatus();
  inline  ::capnp::Text::Builder getCommandStatus();
  inline void setCommandStatus( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initCommandStatus(unsigned int size);
  inline void adoptCommandStatus(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownCommandStatus();

  inline bool hasCurve();
  inline  ::cereal::SlcState::CurveState::Builder getCurve();
  inline void setCurve( ::cereal::SlcState::CurveState::Reader value);
  inline  ::cereal::SlcState::CurveState::Builder initCurve();
  inline void adoptCurve(::capnp::Orphan< ::cereal::SlcState::CurveState>&& value);
  inline ::capnp::Orphan< ::cereal::SlcState::CurveState> disownCurve();

  inline bool hasConditionalMode();
  inline  ::cereal::SlcState::ConditionalModeState::Builder getConditionalMode();
  inline void setConditionalMode( ::cereal::SlcState::ConditionalModeState::Reader value);
  inline  ::cereal::SlcState::ConditionalModeState::Builder initConditionalMode();
  inline void adoptConditionalMode(::capnp::Orphan< ::cereal::SlcState::ConditionalModeState>&& value);
  inline ::capnp::Orphan< ::cereal::SlcState::ConditionalModeState> disownConditionalMode();

  inline bool hasTrafficMode();
  inline  ::cereal::SlcState::TrafficModeState::Builder getTrafficMode();
  inline void setTrafficMode( ::cereal::SlcState::TrafficModeState::Reader value);
  inline  ::cereal::SlcState::TrafficModeState::Builder initTrafficMode();
  inline void adoptTrafficMode(::capnp::Orphan< ::cereal::SlcState::TrafficModeState>&& value);
  inline ::capnp::Orphan< ::cereal::SlcState::TrafficModeState> disownTrafficMode();

  inline bool hasSwitchbackMode();
  inline  ::cereal::SlcState::SwitchbackModeState::Builder getSwitchbackMode();
  inline void setSwitchbackMode( ::cereal::SlcState::SwitchbackModeState::Reader value);
  inline  ::cereal::SlcState::SwitchbackModeState::Builder initSwitchbackMode();
  inline void adoptSwitchbackMode(::capnp::Orphan< ::cereal::SlcState::SwitchbackModeState>&& value);
  inline ::capnp::Orphan< ::cereal::SlcState::SwitchbackModeState> disownSwitchbackMode();

  inline bool hasAcceptedSource();
  inline  ::capnp::Text::Builder getAcceptedSource();
  inline void setAcceptedSource( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initAcceptedSource(unsigned int size);
  inline void adoptAcceptedSource(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownAcceptedSource();

  inline bool hasPendingSource();
  inline  ::capnp::Text::Builder getPendingSource();
  inline void setPendingSource( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initPendingSource(unsigned int size);
  inline void adoptPendingSource(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownPendingSource();

  inline float getEffectiveClusterTarget();
  inline void setEffectiveClusterTarget(float value);

  inline bool getHasEffectiveClusterTarget();
  inline void setHasEffectiveClusterTarget(bool value);

  inline bool getIsLimitingMaxSet();
  inline void setIsLimitingMaxSet(bool value);

  inline bool getDriverOverrideActive();
  inline void setDriverOverrideActive(bool value);

  inline bool hasSourceReadings();
  inline  ::capnp::List< ::cereal::SlcState::SourceReading,  ::capnp::Kind::STRUCT>::Builder getSourceReadings();
  inline void setSourceReadings( ::capnp::List< ::cereal::SlcState::SourceReading,  ::capnp::Kind::STRUCT>::Reader value);
  inline  ::capnp::List< ::cereal::SlcState::SourceReading,  ::capnp::Kind::STRUCT>::Builder initSourceReadings(unsigned int size);
  inline void adoptSourceReadings(::capnp::Orphan< ::capnp::List< ::cereal::SlcState::SourceReading,  ::capnp::Kind::STRUCT>>&& value);
  inline ::capnp::Orphan< ::capnp::List< ::cereal::SlcState::SourceReading,  ::capnp::Kind::STRUCT>> disownSourceReadings();

  inline float getAcceptedAdjustedLimit();
  inline void setAcceptedAdjustedLimit(float value);

  inline bool getHasAcceptedAdjustedLimit();
  inline void setHasAcceptedAdjustedLimit(bool value);

  inline float getPendingAdjustedLimit();
  inline void setPendingAdjustedLimit(float value);

  inline bool getHasPendingAdjustedLimit();
  inline void setHasPendingAdjustedLimit(bool value);

  inline float getPresentationAdjustedLimit();
  inline void setPresentationAdjustedLimit(float value);

  inline bool getHasPresentationAdjustedLimit();
  inline void setHasPresentationAdjustedLimit(bool value);

  inline bool hasOverrideBasis();
  inline  ::capnp::Text::Builder getOverrideBasis();
  inline void setOverrideBasis( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initOverrideBasis(unsigned int size);
  inline void adoptOverrideBasis(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownOverrideBasis();

  inline bool getRetainedOverride();
  inline void setRetainedOverride(bool value);

  inline  ::uint64_t getCommandActionSequenceId();
  inline void setCommandActionSequenceId( ::uint64_t value);

  inline bool getAutomaticAdoptionPending();
  inline void setAutomaticAdoptionPending(bool value);

  inline  ::uint64_t getPendingSinceMonoTime();
  inline void setPendingSinceMonoTime( ::uint64_t value);

  inline float getLastReceivedSpeedLimit();
  inline void setLastReceivedSpeedLimit(float value);

  inline bool hasLastReceivedSource();
  inline  ::capnp::Text::Builder getLastReceivedSource();
  inline void setLastReceivedSource( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initLastReceivedSource(unsigned int size);
  inline void adoptLastReceivedSource(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownLastReceivedSource();

  inline float getLastReceivedAdjustedLimit();
  inline void setLastReceivedAdjustedLimit(float 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 SlcState::Pipeline {
public:
  typedef SlcState Pipelines;

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

  inline  ::cereal::SlcState::CurveState::Pipeline getCurve();
  inline  ::cereal::SlcState::ConditionalModeState::Pipeline getConditionalMode();
  inline  ::cereal::SlcState::TrafficModeState::Pipeline getTrafficMode();
  inline  ::cereal::SlcState::SwitchbackModeState::Pipeline getSwitchbackMode();
private:
  ::capnp::AnyPointer::Pipeline _typeless;
  friend class ::capnp::PipelineHook;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
};
#endif  // !CAPNP_LITE

class SlcState::SourceReading::Reader {
public:
  typedef SourceReading 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 hasSource() const;
  inline  ::capnp::Text::Reader getSource() const;

  inline bool getEnabled() const;

  inline bool hasObservationKind() const;
  inline  ::capnp::Text::Reader getObservationKind() const;

  inline float getSpeedLimit() 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 SlcState::SourceReading::Builder {
public:
  typedef SourceReading 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 hasSource();
  inline  ::capnp::Text::Builder getSource();
  inline void setSource( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initSource(unsigned int size);
  inline void adoptSource(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownSource();

  inline bool getEnabled();
  inline void setEnabled(bool value);

  inline bool hasObservationKind();
  inline  ::capnp::Text::Builder getObservationKind();
  inline void setObservationKind( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initObservationKind(unsigned int size);
  inline void adoptObservationKind(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownObservationKind();

  inline float getSpeedLimit();
  inline void setSpeedLimit(float 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 SlcState::SourceReading::Pipeline {
public:
  typedef SourceReading 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 SlcState::SwitchbackModeState::Reader {
public:
  typedef SwitchbackModeState 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  ::uint16_t getVersion() const;

  inline bool hasSessionId() const;
  inline  ::capnp::Text::Reader getSessionId() const;

  inline  ::uint64_t getSequence() const;

  inline  ::uint64_t getObservedMonoTime() const;

  inline  ::uint64_t getValidUntilMonoTime() const;

  inline  ::uint64_t getDriveStartMonoTime() const;

  inline bool getRequested() const;

  inline bool getEffective() const;

  inline  ::uint64_t getSourceCarControlMonoTime() 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 SlcState::SwitchbackModeState::Builder {
public:
  typedef SwitchbackModeState 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  ::uint16_t getVersion();
  inline void setVersion( ::uint16_t value);

  inline bool hasSessionId();
  inline  ::capnp::Text::Builder getSessionId();
  inline void setSessionId( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initSessionId(unsigned int size);
  inline void adoptSessionId(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownSessionId();

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

  inline  ::uint64_t getObservedMonoTime();
  inline void setObservedMonoTime( ::uint64_t value);

  inline  ::uint64_t getValidUntilMonoTime();
  inline void setValidUntilMonoTime( ::uint64_t value);

  inline  ::uint64_t getDriveStartMonoTime();
  inline void setDriveStartMonoTime( ::uint64_t value);

  inline bool getRequested();
  inline void setRequested(bool value);

  inline bool getEffective();
  inline void setEffective(bool value);

  inline  ::uint64_t getSourceCarControlMonoTime();
  inline void setSourceCarControlMonoTime( ::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 SlcState::SwitchbackModeState::Pipeline {
public:
  typedef SwitchbackModeState 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 SlcState::TrafficModeState::Reader {
public:
  typedef TrafficModeState 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  ::uint16_t getVersion() const;

  inline bool hasSessionId() const;
  inline  ::capnp::Text::Reader getSessionId() const;

  inline  ::uint64_t getSequence() const;

  inline  ::uint64_t getObservedMonoTime() const;

  inline  ::uint64_t getValidUntilMonoTime() const;

  inline  ::uint64_t getDriveStartMonoTime() const;

  inline  ::uint64_t getSourceEpoch() const;

  inline  ::uint64_t getSourceBootTime() const;

  inline bool getAccepted() const;

  inline bool getEffective() const;

  inline bool hasReason() const;
  inline  ::capnp::Text::Reader getReason() const;

  inline bool hasSettingsFingerprint() const;
  inline  ::capnp::Text::Reader getSettingsFingerprint() const;

  inline bool hasButtonMapFingerprint() const;
  inline  ::capnp::Text::Reader getButtonMapFingerprint() const;

  inline bool getProfileTargetReady() const;

  inline bool hasProfileReason() const;
  inline  ::capnp::Text::Reader getProfileReason() const;

  inline bool getControllerSource() 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 SlcState::TrafficModeState::Builder {
public:
  typedef TrafficModeState 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  ::uint16_t getVersion();
  inline void setVersion( ::uint16_t value);

  inline bool hasSessionId();
  inline  ::capnp::Text::Builder getSessionId();
  inline void setSessionId( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initSessionId(unsigned int size);
  inline void adoptSessionId(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownSessionId();

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

  inline  ::uint64_t getObservedMonoTime();
  inline void setObservedMonoTime( ::uint64_t value);

  inline  ::uint64_t getValidUntilMonoTime();
  inline void setValidUntilMonoTime( ::uint64_t value);

  inline  ::uint64_t getDriveStartMonoTime();
  inline void setDriveStartMonoTime( ::uint64_t value);

  inline  ::uint64_t getSourceEpoch();
  inline void setSourceEpoch( ::uint64_t value);

  inline  ::uint64_t getSourceBootTime();
  inline void setSourceBootTime( ::uint64_t value);

  inline bool getAccepted();
  inline void setAccepted(bool value);

  inline bool getEffective();
  inline void setEffective(bool value);

  inline bool hasReason();
  inline  ::capnp::Text::Builder getReason();
  inline void setReason( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initReason(unsigned int size);
  inline void adoptReason(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownReason();

  inline bool hasSettingsFingerprint();
  inline  ::capnp::Text::Builder getSettingsFingerprint();
  inline void setSettingsFingerprint( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initSettingsFingerprint(unsigned int size);
  inline void adoptSettingsFingerprint(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownSettingsFingerprint();

  inline bool hasButtonMapFingerprint();
  inline  ::capnp::Text::Builder getButtonMapFingerprint();
  inline void setButtonMapFingerprint( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initButtonMapFingerprint(unsigned int size);
  inline void adoptButtonMapFingerprint(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownButtonMapFingerprint();

  inline bool getProfileTargetReady();
  inline void setProfileTargetReady(bool value);

  inline bool hasProfileReason();
  inline  ::capnp::Text::Builder getProfileReason();
  inline void setProfileReason( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initProfileReason(unsigned int size);
  inline void adoptProfileReason(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownProfileReason();

  inline bool getControllerSource();
  inline void setControllerSource(bool 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 SlcState::TrafficModeState::Pipeline {
public:
  typedef TrafficModeState 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 SlcState::CurveState::Reader {
public:
  typedef CurveState 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  ::uint16_t getVersion() const;

  inline bool hasSessionId() const;
  inline  ::capnp::Text::Reader getSessionId() const;

  inline  ::uint64_t getSequence() const;

  inline  ::uint64_t getObservedMonoTime() const;

  inline  ::uint64_t getValidUntilMonoTime() const;

  inline  ::uint64_t getModelMonoTime() const;

  inline bool getConfigured() const;

  inline bool getDocumentValid() const;

  inline bool getHasCandidate() const;

  inline float getCandidateMps() const;

  inline bool getHasCeiling() const;

  inline float getCeilingMps() const;

  inline bool getApplied() const;

  inline bool getControlling() const;

  inline bool getTraining() const;

  inline float getCalibrationProgress() const;

  inline float getComfortAccel() const;

  inline float getBindingDistance() const;

  inline bool hasReason() const;
  inline  ::capnp::Text::Reader getReason() const;

  inline bool hasPlannerStatus() const;
  inline  ::capnp::Text::Reader getPlannerStatus() const;

  inline bool hasPersistenceStatus() const;
  inline  ::capnp::Text::Reader getPersistenceStatus() const;

  inline bool getGlow() const;

  inline bool getCurveOnly() const;

  inline bool getHasRoadCurvature() const;

  inline float getRoadCurvature() 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 SlcState::CurveState::Builder {
public:
  typedef CurveState 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  ::uint16_t getVersion();
  inline void setVersion( ::uint16_t value);

  inline bool hasSessionId();
  inline  ::capnp::Text::Builder getSessionId();
  inline void setSessionId( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initSessionId(unsigned int size);
  inline void adoptSessionId(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownSessionId();

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

  inline  ::uint64_t getObservedMonoTime();
  inline void setObservedMonoTime( ::uint64_t value);

  inline  ::uint64_t getValidUntilMonoTime();
  inline void setValidUntilMonoTime( ::uint64_t value);

  inline  ::uint64_t getModelMonoTime();
  inline void setModelMonoTime( ::uint64_t value);

  inline bool getConfigured();
  inline void setConfigured(bool value);

  inline bool getDocumentValid();
  inline void setDocumentValid(bool value);

  inline bool getHasCandidate();
  inline void setHasCandidate(bool value);

  inline float getCandidateMps();
  inline void setCandidateMps(float value);

  inline bool getHasCeiling();
  inline void setHasCeiling(bool value);

  inline float getCeilingMps();
  inline void setCeilingMps(float value);

  inline bool getApplied();
  inline void setApplied(bool value);

  inline bool getControlling();
  inline void setControlling(bool value);

  inline bool getTraining();
  inline void setTraining(bool value);

  inline float getCalibrationProgress();
  inline void setCalibrationProgress(float value);

  inline float getComfortAccel();
  inline void setComfortAccel(float value);

  inline float getBindingDistance();
  inline void setBindingDistance(float value);

  inline bool hasReason();
  inline  ::capnp::Text::Builder getReason();
  inline void setReason( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initReason(unsigned int size);
  inline void adoptReason(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownReason();

  inline bool hasPlannerStatus();
  inline  ::capnp::Text::Builder getPlannerStatus();
  inline void setPlannerStatus( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initPlannerStatus(unsigned int size);
  inline void adoptPlannerStatus(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownPlannerStatus();

  inline bool hasPersistenceStatus();
  inline  ::capnp::Text::Builder getPersistenceStatus();
  inline void setPersistenceStatus( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initPersistenceStatus(unsigned int size);
  inline void adoptPersistenceStatus(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownPersistenceStatus();

  inline bool getGlow();
  inline void setGlow(bool value);

  inline bool getCurveOnly();
  inline void setCurveOnly(bool value);

  inline bool getHasRoadCurvature();
  inline void setHasRoadCurvature(bool value);

  inline float getRoadCurvature();
  inline void setRoadCurvature(float 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 SlcState::CurveState::Pipeline {
public:
  typedef CurveState 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 SlcState::ConditionalModeState::Reader {
public:
  typedef ConditionalModeState 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  ::uint16_t getVersion() const;

  inline bool hasSessionId() const;
  inline  ::capnp::Text::Reader getSessionId() const;

  inline  ::uint64_t getSequence() const;

  inline  ::uint64_t getObservedMonoTime() const;

  inline  ::uint64_t getValidUntilMonoTime() const;

  inline  ::uint64_t getDriveStartMonoTime() const;

  inline  ::uint64_t getModelMonoTime() const;

  inline  ::uint64_t getCarStateMonoTime() const;

  inline  ::uint64_t getSettingsRevision() const;

  inline bool hasSettingsFingerprint() const;
  inline  ::capnp::Text::Reader getSettingsFingerprint() const;

  inline  ::cereal::SlcState::ConditionalModeState::Choice getChoice() const;

  inline bool getHasOverride() const;

  inline bool getExperimental() const;

  inline bool hasStatus() const;
  inline  ::capnp::Text::Reader getStatus() const;

  inline bool hasReason() const;
  inline  ::capnp::Text::Reader getReason() const;

  inline  ::uint16_t getStatusCode() 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 SlcState::ConditionalModeState::Builder {
public:
  typedef ConditionalModeState 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  ::uint16_t getVersion();
  inline void setVersion( ::uint16_t value);

  inline bool hasSessionId();
  inline  ::capnp::Text::Builder getSessionId();
  inline void setSessionId( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initSessionId(unsigned int size);
  inline void adoptSessionId(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownSessionId();

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

  inline  ::uint64_t getObservedMonoTime();
  inline void setObservedMonoTime( ::uint64_t value);

  inline  ::uint64_t getValidUntilMonoTime();
  inline void setValidUntilMonoTime( ::uint64_t value);

  inline  ::uint64_t getDriveStartMonoTime();
  inline void setDriveStartMonoTime( ::uint64_t value);

  inline  ::uint64_t getModelMonoTime();
  inline void setModelMonoTime( ::uint64_t value);

  inline  ::uint64_t getCarStateMonoTime();
  inline void setCarStateMonoTime( ::uint64_t value);

  inline  ::uint64_t getSettingsRevision();
  inline void setSettingsRevision( ::uint64_t value);

  inline bool hasSettingsFingerprint();
  inline  ::capnp::Text::Builder getSettingsFingerprint();
  inline void setSettingsFingerprint( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initSettingsFingerprint(unsigned int size);
  inline void adoptSettingsFingerprint(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownSettingsFingerprint();

  inline  ::cereal::SlcState::ConditionalModeState::Choice getChoice();
  inline void setChoice( ::cereal::SlcState::ConditionalModeState::Choice value);

  inline bool getHasOverride();
  inline void setHasOverride(bool value);

  inline bool getExperimental();
  inline void setExperimental(bool value);

  inline bool hasStatus();
  inline  ::capnp::Text::Builder getStatus();
  inline void setStatus( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initStatus(unsigned int size);
  inline void adoptStatus(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownStatus();

  inline bool hasReason();
  inline  ::capnp::Text::Builder getReason();
  inline void setReason( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initReason(unsigned int size);
  inline void adoptReason(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownReason();

  inline  ::uint16_t getStatusCode();
  inline void setStatusCode( ::uint16_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 SlcState::ConditionalModeState::Pipeline {
public:
  typedef ConditionalModeState 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 SlcAction::Reader {
public:
  typedef SlcAction 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 hasSessionId() const;
  inline  ::capnp::Text::Reader getSessionId() const;

  inline  ::uint64_t getSequenceId() const;

  inline  ::uint64_t getDecisionId() const;

  inline  ::uint64_t getPresentationId() const;

  inline  ::cereal::SlcAction::Kind getKind() const;

  inline bool hasConditionalManual() const;
  inline  ::cereal::SlcAction::ConditionalManualAction::Reader getConditionalManual() const;

  inline bool hasControllerCruise() const;
  inline  ::cereal::SlcAction::ControllerCruiseAction::Reader getControllerCruise() const;

  inline bool hasControllerMode() const;
  inline  ::cereal::SlcAction::ControllerCruiseAction::Reader getControllerMode() 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 SlcAction::Builder {
public:
  typedef SlcAction 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 hasSessionId();
  inline  ::capnp::Text::Builder getSessionId();
  inline void setSessionId( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initSessionId(unsigned int size);
  inline void adoptSessionId(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownSessionId();

  inline  ::uint64_t getSequenceId();
  inline void setSequenceId( ::uint64_t value);

  inline  ::uint64_t getDecisionId();
  inline void setDecisionId( ::uint64_t value);

  inline  ::uint64_t getPresentationId();
  inline void setPresentationId( ::uint64_t value);

  inline  ::cereal::SlcAction::Kind getKind();
  inline void setKind( ::cereal::SlcAction::Kind value);

  inline bool hasConditionalManual();
  inline  ::cereal::SlcAction::ConditionalManualAction::Builder getConditionalManual();
  inline void setConditionalManual( ::cereal::SlcAction::ConditionalManualAction::Reader value);
  inline  ::cereal::SlcAction::ConditionalManualAction::Builder initConditionalManual();
  inline void adoptConditionalManual(::capnp::Orphan< ::cereal::SlcAction::ConditionalManualAction>&& value);
  inline ::capnp::Orphan< ::cereal::SlcAction::ConditionalManualAction> disownConditionalManual();

  inline bool hasControllerCruise();
  inline  ::cereal::SlcAction::ControllerCruiseAction::Builder getControllerCruise();
  inline void setControllerCruise( ::cereal::SlcAction::ControllerCruiseAction::Reader value);
  inline  ::cereal::SlcAction::ControllerCruiseAction::Builder initControllerCruise();
  inline void adoptControllerCruise(::capnp::Orphan< ::cereal::SlcAction::ControllerCruiseAction>&& value);
  inline ::capnp::Orphan< ::cereal::SlcAction::ControllerCruiseAction> disownControllerCruise();

  inline bool hasControllerMode();
  inline  ::cereal::SlcAction::ControllerCruiseAction::Builder getControllerMode();
  inline void setControllerMode( ::cereal::SlcAction::ControllerCruiseAction::Reader value);
  inline  ::cereal::SlcAction::ControllerCruiseAction::Builder initControllerMode();
  inline void adoptControllerMode(::capnp::Orphan< ::cereal::SlcAction::ControllerCruiseAction>&& value);
  inline ::capnp::Orphan< ::cereal::SlcAction::ControllerCruiseAction> disownControllerMode();

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 SlcAction::Pipeline {
public:
  typedef SlcAction Pipelines;

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

  inline  ::cereal::SlcAction::ConditionalManualAction::Pipeline getConditionalManual();
  inline  ::cereal::SlcAction::ControllerCruiseAction::Pipeline getControllerCruise();
  inline  ::cereal::SlcAction::ControllerCruiseAction::Pipeline getControllerMode();
private:
  ::capnp::AnyPointer::Pipeline _typeless;
  friend class ::capnp::PipelineHook;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
};
#endif  // !CAPNP_LITE

class SlcAction::ControllerCruiseAction::Reader {
public:
  typedef ControllerCruiseAction 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  ::uint16_t getVersion() const;

  inline bool hasSessionId() const;
  inline  ::capnp::Text::Reader getSessionId() const;

  inline  ::uint64_t getSequence() const;

  inline  ::uint64_t getObservedMonoTime() const;

  inline  ::uint64_t getValidUntilMonoTime() const;

  inline  ::uint64_t getDriveStartMonoTime() const;

  inline bool hasCarFingerprint() const;
  inline  ::capnp::Text::Reader getCarFingerprint() const;

  inline  ::uint64_t getSourceCarControlMonoTime() const;

  inline  ::uint8_t getActionCode() const;

  inline bool hasButtonKey() const;
  inline  ::capnp::Text::Reader getButtonKey() const;

  inline  ::uint64_t getSourceCarStateMonoTime() const;

  inline bool hasCarParamsFingerprint() const;
  inline  ::capnp::Text::Reader getCarParamsFingerprint() const;

  inline float getTargetSpeedMps() 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 SlcAction::ControllerCruiseAction::Builder {
public:
  typedef ControllerCruiseAction 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  ::uint16_t getVersion();
  inline void setVersion( ::uint16_t value);

  inline bool hasSessionId();
  inline  ::capnp::Text::Builder getSessionId();
  inline void setSessionId( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initSessionId(unsigned int size);
  inline void adoptSessionId(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownSessionId();

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

  inline  ::uint64_t getObservedMonoTime();
  inline void setObservedMonoTime( ::uint64_t value);

  inline  ::uint64_t getValidUntilMonoTime();
  inline void setValidUntilMonoTime( ::uint64_t value);

  inline  ::uint64_t getDriveStartMonoTime();
  inline void setDriveStartMonoTime( ::uint64_t value);

  inline bool hasCarFingerprint();
  inline  ::capnp::Text::Builder getCarFingerprint();
  inline void setCarFingerprint( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initCarFingerprint(unsigned int size);
  inline void adoptCarFingerprint(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownCarFingerprint();

  inline  ::uint64_t getSourceCarControlMonoTime();
  inline void setSourceCarControlMonoTime( ::uint64_t value);

  inline  ::uint8_t getActionCode();
  inline void setActionCode( ::uint8_t value);

  inline bool hasButtonKey();
  inline  ::capnp::Text::Builder getButtonKey();
  inline void setButtonKey( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initButtonKey(unsigned int size);
  inline void adoptButtonKey(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownButtonKey();

  inline  ::uint64_t getSourceCarStateMonoTime();
  inline void setSourceCarStateMonoTime( ::uint64_t value);

  inline bool hasCarParamsFingerprint();
  inline  ::capnp::Text::Builder getCarParamsFingerprint();
  inline void setCarParamsFingerprint( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initCarParamsFingerprint(unsigned int size);
  inline void adoptCarParamsFingerprint(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownCarParamsFingerprint();

  inline float getTargetSpeedMps();
  inline void setTargetSpeedMps(float 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 SlcAction::ControllerCruiseAction::Pipeline {
public:
  typedef ControllerCruiseAction 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 SlcAction::ConditionalManualAction::Reader {
public:
  typedef ConditionalManualAction 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  ::uint16_t getVersion() const;

  inline bool hasSessionId() const;
  inline  ::capnp::Text::Reader getSessionId() const;

  inline  ::uint64_t getSequence() const;

  inline  ::uint64_t getObservedMonoTime() const;

  inline  ::uint64_t getValidUntilMonoTime() const;

  inline  ::uint64_t getDriveStartMonoTime() const;

  inline bool hasSettingsFingerprint() const;
  inline  ::capnp::Text::Reader getSettingsFingerprint() const;

  inline  ::cereal::SlcState::ConditionalModeState::Choice getChoice() const;

  inline bool hasPlannerSessionId() const;
  inline  ::capnp::Text::Reader getPlannerSessionId() const;

  inline  ::uint64_t getSourceCarStateMonoTime() const;

  inline  ::uint64_t getSourceSelfdriveStateMonoTime() const;

  inline  ::uint8_t getExpectedManualCode() const;

  inline bool getExpectedExperimental() 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 SlcAction::ConditionalManualAction::Builder {
public:
  typedef ConditionalManualAction 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  ::uint16_t getVersion();
  inline void setVersion( ::uint16_t value);

  inline bool hasSessionId();
  inline  ::capnp::Text::Builder getSessionId();
  inline void setSessionId( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initSessionId(unsigned int size);
  inline void adoptSessionId(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownSessionId();

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

  inline  ::uint64_t getObservedMonoTime();
  inline void setObservedMonoTime( ::uint64_t value);

  inline  ::uint64_t getValidUntilMonoTime();
  inline void setValidUntilMonoTime( ::uint64_t value);

  inline  ::uint64_t getDriveStartMonoTime();
  inline void setDriveStartMonoTime( ::uint64_t value);

  inline bool hasSettingsFingerprint();
  inline  ::capnp::Text::Builder getSettingsFingerprint();
  inline void setSettingsFingerprint( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initSettingsFingerprint(unsigned int size);
  inline void adoptSettingsFingerprint(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownSettingsFingerprint();

  inline  ::cereal::SlcState::ConditionalModeState::Choice getChoice();
  inline void setChoice( ::cereal::SlcState::ConditionalModeState::Choice value);

  inline bool hasPlannerSessionId();
  inline  ::capnp::Text::Builder getPlannerSessionId();
  inline void setPlannerSessionId( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initPlannerSessionId(unsigned int size);
  inline void adoptPlannerSessionId(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownPlannerSessionId();

  inline  ::uint64_t getSourceCarStateMonoTime();
  inline void setSourceCarStateMonoTime( ::uint64_t value);

  inline  ::uint64_t getSourceSelfdriveStateMonoTime();
  inline void setSourceSelfdriveStateMonoTime( ::uint64_t value);

  inline  ::uint8_t getExpectedManualCode();
  inline void setExpectedManualCode( ::uint8_t value);

  inline bool getExpectedExperimental();
  inline void setExpectedExperimental(bool 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 SlcAction::ConditionalManualAction::Pipeline {
public:
  typedef ConditionalManualAction 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 SlcCruiseEvent::Reader {
public:
  typedef SlcCruiseEvent 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  ::uint64_t getEventId() const;

  inline  ::uint64_t getObservedMonoTime() const;

  inline float getPreviousMps() const;

  inline float getSelectedMps() const;

  inline  ::cereal::SlcCruiseEvent::Button getButton() const;

  inline bool getLongPress() const;

  inline bool hasProducerSessionId() const;
  inline  ::capnp::Text::Reader getProducerSessionId() const;

  inline  ::cereal::SlcCruiseEvent::Kind getKind() const;

  inline bool hasSessionId() const;
  inline  ::capnp::Text::Reader getSessionId() const;

  inline  ::uint64_t getDecisionId() const;

  inline  ::uint64_t getPresentationId() const;

  inline  ::uint64_t getCommandId() const;

  inline bool hasManualMode() const;
  inline  ::cereal::SlcCruiseEvent::ManualModeGesture::Reader getManualMode() const;

  inline bool hasTrafficMode() const;
  inline  ::cereal::SlcCruiseEvent::TrafficModeGesture::Reader getTrafficMode() const;

  inline bool hasWheelAction() const;
  inline  ::cereal::SlcAction::ControllerCruiseAction::Reader getWheelAction() const;

  inline bool hasTeslaStockCruise() const;
  inline  ::cereal::SlcCruiseEvent::TeslaStockCruise::Reader getTeslaStockCruise() 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 SlcCruiseEvent::Builder {
public:
  typedef SlcCruiseEvent 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  ::uint64_t getEventId();
  inline void setEventId( ::uint64_t value);

  inline  ::uint64_t getObservedMonoTime();
  inline void setObservedMonoTime( ::uint64_t value);

  inline float getPreviousMps();
  inline void setPreviousMps(float value);

  inline float getSelectedMps();
  inline void setSelectedMps(float value);

  inline  ::cereal::SlcCruiseEvent::Button getButton();
  inline void setButton( ::cereal::SlcCruiseEvent::Button value);

  inline bool getLongPress();
  inline void setLongPress(bool value);

  inline bool hasProducerSessionId();
  inline  ::capnp::Text::Builder getProducerSessionId();
  inline void setProducerSessionId( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initProducerSessionId(unsigned int size);
  inline void adoptProducerSessionId(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownProducerSessionId();

  inline  ::cereal::SlcCruiseEvent::Kind getKind();
  inline void setKind( ::cereal::SlcCruiseEvent::Kind value);

  inline bool hasSessionId();
  inline  ::capnp::Text::Builder getSessionId();
  inline void setSessionId( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initSessionId(unsigned int size);
  inline void adoptSessionId(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownSessionId();

  inline  ::uint64_t getDecisionId();
  inline void setDecisionId( ::uint64_t value);

  inline  ::uint64_t getPresentationId();
  inline void setPresentationId( ::uint64_t value);

  inline  ::uint64_t getCommandId();
  inline void setCommandId( ::uint64_t value);

  inline bool hasManualMode();
  inline  ::cereal::SlcCruiseEvent::ManualModeGesture::Builder getManualMode();
  inline void setManualMode( ::cereal::SlcCruiseEvent::ManualModeGesture::Reader value);
  inline  ::cereal::SlcCruiseEvent::ManualModeGesture::Builder initManualMode();
  inline void adoptManualMode(::capnp::Orphan< ::cereal::SlcCruiseEvent::ManualModeGesture>&& value);
  inline ::capnp::Orphan< ::cereal::SlcCruiseEvent::ManualModeGesture> disownManualMode();

  inline bool hasTrafficMode();
  inline  ::cereal::SlcCruiseEvent::TrafficModeGesture::Builder getTrafficMode();
  inline void setTrafficMode( ::cereal::SlcCruiseEvent::TrafficModeGesture::Reader value);
  inline  ::cereal::SlcCruiseEvent::TrafficModeGesture::Builder initTrafficMode();
  inline void adoptTrafficMode(::capnp::Orphan< ::cereal::SlcCruiseEvent::TrafficModeGesture>&& value);
  inline ::capnp::Orphan< ::cereal::SlcCruiseEvent::TrafficModeGesture> disownTrafficMode();

  inline bool hasWheelAction();
  inline  ::cereal::SlcAction::ControllerCruiseAction::Builder getWheelAction();
  inline void setWheelAction( ::cereal::SlcAction::ControllerCruiseAction::Reader value);
  inline  ::cereal::SlcAction::ControllerCruiseAction::Builder initWheelAction();
  inline void adoptWheelAction(::capnp::Orphan< ::cereal::SlcAction::ControllerCruiseAction>&& value);
  inline ::capnp::Orphan< ::cereal::SlcAction::ControllerCruiseAction> disownWheelAction();

  inline bool hasTeslaStockCruise();
  inline  ::cereal::SlcCruiseEvent::TeslaStockCruise::Builder getTeslaStockCruise();
  inline void setTeslaStockCruise( ::cereal::SlcCruiseEvent::TeslaStockCruise::Reader value);
  inline  ::cereal::SlcCruiseEvent::TeslaStockCruise::Builder initTeslaStockCruise();
  inline void adoptTeslaStockCruise(::capnp::Orphan< ::cereal::SlcCruiseEvent::TeslaStockCruise>&& value);
  inline ::capnp::Orphan< ::cereal::SlcCruiseEvent::TeslaStockCruise> disownTeslaStockCruise();

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 SlcCruiseEvent::Pipeline {
public:
  typedef SlcCruiseEvent Pipelines;

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

  inline  ::cereal::SlcCruiseEvent::ManualModeGesture::Pipeline getManualMode();
  inline  ::cereal::SlcCruiseEvent::TrafficModeGesture::Pipeline getTrafficMode();
  inline  ::cereal::SlcAction::ControllerCruiseAction::Pipeline getWheelAction();
  inline  ::cereal::SlcCruiseEvent::TeslaStockCruise::Pipeline getTeslaStockCruise();
private:
  ::capnp::AnyPointer::Pipeline _typeless;
  friend class ::capnp::PipelineHook;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
};
#endif  // !CAPNP_LITE

class SlcCruiseEvent::TeslaStockCruise::Reader {
public:
  typedef TeslaStockCruise 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  ::uint16_t getVersion() const;

  inline  ::uint64_t getCarStateMonoTime() const;

  inline bool hasCpFingerprint() const;
  inline  ::capnp::Text::Reader getCpFingerprint() const;

  inline bool getEngaged() const;

  inline bool getNotArmed() 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 SlcCruiseEvent::TeslaStockCruise::Builder {
public:
  typedef TeslaStockCruise 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  ::uint16_t getVersion();
  inline void setVersion( ::uint16_t value);

  inline  ::uint64_t getCarStateMonoTime();
  inline void setCarStateMonoTime( ::uint64_t value);

  inline bool hasCpFingerprint();
  inline  ::capnp::Text::Builder getCpFingerprint();
  inline void setCpFingerprint( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initCpFingerprint(unsigned int size);
  inline void adoptCpFingerprint(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownCpFingerprint();

  inline bool getEngaged();
  inline void setEngaged(bool value);

  inline bool getNotArmed();
  inline void setNotArmed(bool 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 SlcCruiseEvent::TeslaStockCruise::Pipeline {
public:
  typedef TeslaStockCruise 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 SlcCruiseEvent::TrafficModeGesture::Reader {
public:
  typedef TrafficModeGesture 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  ::uint16_t getVersion() const;

  inline bool hasSessionId() const;
  inline  ::capnp::Text::Reader getSessionId() const;

  inline  ::uint64_t getSequence() const;

  inline  ::uint64_t getObservedMonoTime() const;

  inline  ::uint64_t getDriveStartMonoTime() const;

  inline bool hasSettingsFingerprint() const;
  inline  ::capnp::Text::Reader getSettingsFingerprint() const;

  inline bool hasButtonMapFingerprint() const;
  inline  ::capnp::Text::Reader getButtonMapFingerprint() const;

  inline  ::uint64_t getSourceEpoch() const;

  inline  ::uint64_t getSourceBootTime() const;

  inline  ::uint64_t getSourceCarStateMonoTime() const;

  inline  ::uint64_t getValidUntilMonoTime() const;

  inline bool getToggle() const;

  inline  ::cereal::SlcCruiseEvent::TrafficModeGesture::Button getButton() const;

  inline  ::cereal::SlcCruiseEvent::TrafficModeGesture::Press getPress() 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 SlcCruiseEvent::TrafficModeGesture::Builder {
public:
  typedef TrafficModeGesture 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  ::uint16_t getVersion();
  inline void setVersion( ::uint16_t value);

  inline bool hasSessionId();
  inline  ::capnp::Text::Builder getSessionId();
  inline void setSessionId( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initSessionId(unsigned int size);
  inline void adoptSessionId(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownSessionId();

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

  inline  ::uint64_t getObservedMonoTime();
  inline void setObservedMonoTime( ::uint64_t value);

  inline  ::uint64_t getDriveStartMonoTime();
  inline void setDriveStartMonoTime( ::uint64_t value);

  inline bool hasSettingsFingerprint();
  inline  ::capnp::Text::Builder getSettingsFingerprint();
  inline void setSettingsFingerprint( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initSettingsFingerprint(unsigned int size);
  inline void adoptSettingsFingerprint(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownSettingsFingerprint();

  inline bool hasButtonMapFingerprint();
  inline  ::capnp::Text::Builder getButtonMapFingerprint();
  inline void setButtonMapFingerprint( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initButtonMapFingerprint(unsigned int size);
  inline void adoptButtonMapFingerprint(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownButtonMapFingerprint();

  inline  ::uint64_t getSourceEpoch();
  inline void setSourceEpoch( ::uint64_t value);

  inline  ::uint64_t getSourceBootTime();
  inline void setSourceBootTime( ::uint64_t value);

  inline  ::uint64_t getSourceCarStateMonoTime();
  inline void setSourceCarStateMonoTime( ::uint64_t value);

  inline  ::uint64_t getValidUntilMonoTime();
  inline void setValidUntilMonoTime( ::uint64_t value);

  inline bool getToggle();
  inline void setToggle(bool value);

  inline  ::cereal::SlcCruiseEvent::TrafficModeGesture::Button getButton();
  inline void setButton( ::cereal::SlcCruiseEvent::TrafficModeGesture::Button value);

  inline  ::cereal::SlcCruiseEvent::TrafficModeGesture::Press getPress();
  inline void setPress( ::cereal::SlcCruiseEvent::TrafficModeGesture::Press 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 SlcCruiseEvent::TrafficModeGesture::Pipeline {
public:
  typedef TrafficModeGesture 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 SlcCruiseEvent::ManualModeGesture::Reader {
public:
  typedef ManualModeGesture 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  ::uint16_t getVersion() const;

  inline bool hasSessionId() const;
  inline  ::capnp::Text::Reader getSessionId() const;

  inline  ::uint64_t getSequence() const;

  inline  ::uint64_t getObservedMonoTime() const;

  inline  ::uint64_t getDriveStartMonoTime() const;

  inline bool hasSettingsFingerprint() const;
  inline  ::capnp::Text::Reader getSettingsFingerprint() const;

  inline  ::cereal::SlcCruiseEvent::ManualModeGesture::Choice getChoice() const;

  inline  ::cereal::SlcCruiseEvent::ManualModeGesture::Button getButton() const;

  inline  ::cereal::SlcCruiseEvent::ManualModeGesture::Press getPress() const;

  inline  ::uint64_t getSourceCarStateMonoTime() const;

  inline  ::uint64_t getValidUntilMonoTime() 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 SlcCruiseEvent::ManualModeGesture::Builder {
public:
  typedef ManualModeGesture 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  ::uint16_t getVersion();
  inline void setVersion( ::uint16_t value);

  inline bool hasSessionId();
  inline  ::capnp::Text::Builder getSessionId();
  inline void setSessionId( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initSessionId(unsigned int size);
  inline void adoptSessionId(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownSessionId();

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

  inline  ::uint64_t getObservedMonoTime();
  inline void setObservedMonoTime( ::uint64_t value);

  inline  ::uint64_t getDriveStartMonoTime();
  inline void setDriveStartMonoTime( ::uint64_t value);

  inline bool hasSettingsFingerprint();
  inline  ::capnp::Text::Builder getSettingsFingerprint();
  inline void setSettingsFingerprint( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initSettingsFingerprint(unsigned int size);
  inline void adoptSettingsFingerprint(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownSettingsFingerprint();

  inline  ::cereal::SlcCruiseEvent::ManualModeGesture::Choice getChoice();
  inline void setChoice( ::cereal::SlcCruiseEvent::ManualModeGesture::Choice value);

  inline  ::cereal::SlcCruiseEvent::ManualModeGesture::Button getButton();
  inline void setButton( ::cereal::SlcCruiseEvent::ManualModeGesture::Button value);

  inline  ::cereal::SlcCruiseEvent::ManualModeGesture::Press getPress();
  inline void setPress( ::cereal::SlcCruiseEvent::ManualModeGesture::Press value);

  inline  ::uint64_t getSourceCarStateMonoTime();
  inline void setSourceCarStateMonoTime( ::uint64_t value);

  inline  ::uint64_t getValidUntilMonoTime();
  inline void setValidUntilMonoTime( ::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 SlcCruiseEvent::ManualModeGesture::Pipeline {
public:
  typedef ManualModeGesture 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 SlcDashboardObservation::Reader {
public:
  typedef SlcDashboardObservation 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 hasProducerSessionId() const;
  inline  ::capnp::Text::Reader getProducerSessionId() const;

  inline  ::uint64_t getCarStateLogMonoTime() const;

  inline  ::cereal::SlcDashboardObservation::Status getStatus() const;

  inline float getSpeedMps() const;

  inline  ::uint64_t getObservedMonoTime() const;

  inline  ::uint64_t getValidUntilMonoTime() const;

  inline  ::uint32_t getEpisode() 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 SlcDashboardObservation::Builder {
public:
  typedef SlcDashboardObservation 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 hasProducerSessionId();
  inline  ::capnp::Text::Builder getProducerSessionId();
  inline void setProducerSessionId( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initProducerSessionId(unsigned int size);
  inline void adoptProducerSessionId(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownProducerSessionId();

  inline  ::uint64_t getCarStateLogMonoTime();
  inline void setCarStateLogMonoTime( ::uint64_t value);

  inline  ::cereal::SlcDashboardObservation::Status getStatus();
  inline void setStatus( ::cereal::SlcDashboardObservation::Status value);

  inline float getSpeedMps();
  inline void setSpeedMps(float value);

  inline  ::uint64_t getObservedMonoTime();
  inline void setObservedMonoTime( ::uint64_t value);

  inline  ::uint64_t getValidUntilMonoTime();
  inline void setValidUntilMonoTime( ::uint64_t value);

  inline  ::uint32_t getEpisode();
  inline void setEpisode( ::uint32_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 SlcDashboardObservation::Pipeline {
public:
  typedef SlcDashboardObservation 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 StarPilotModelDataV2::Reader {
public:
  typedef StarPilotModelDataV2 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  ::cereal::StarPilotModelDataV2::TurnDirection getTurnDirection() const;

  inline bool hasVision() const;
  inline  ::cereal::StarPilotModelDataV2::VisionObservation::Reader getVision() 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 StarPilotModelDataV2::Builder {
public:
  typedef StarPilotModelDataV2 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  ::cereal::StarPilotModelDataV2::TurnDirection getTurnDirection();
  inline void setTurnDirection( ::cereal::StarPilotModelDataV2::TurnDirection value);

  inline bool hasVision();
  inline  ::cereal::StarPilotModelDataV2::VisionObservation::Builder getVision();
  inline void setVision( ::cereal::StarPilotModelDataV2::VisionObservation::Reader value);
  inline  ::cereal::StarPilotModelDataV2::VisionObservation::Builder initVision();
  inline void adoptVision(::capnp::Orphan< ::cereal::StarPilotModelDataV2::VisionObservation>&& value);
  inline ::capnp::Orphan< ::cereal::StarPilotModelDataV2::VisionObservation> disownVision();

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 StarPilotModelDataV2::Pipeline {
public:
  typedef StarPilotModelDataV2 Pipelines;

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

  inline  ::cereal::StarPilotModelDataV2::VisionObservation::Pipeline getVision();
private:
  ::capnp::AnyPointer::Pipeline _typeless;
  friend class ::capnp::PipelineHook;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
};
#endif  // !CAPNP_LITE

class StarPilotModelDataV2::VisionObservation::Reader {
public:
  typedef VisionObservation 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 hasProducerSessionId() const;
  inline  ::capnp::Text::Reader getProducerSessionId() const;

  inline  ::cereal::StarPilotModelDataV2::VisionObservation::Status getStatus() const;

  inline float getSpeedMps() const;

  inline float getConfidence() const;

  inline  ::uint16_t getSupportCount() const;

  inline  ::uint64_t getObservedMonoTime() const;

  inline  ::uint64_t getValidUntilMonoTime() const;

  inline  ::uint64_t getCameraFrameEofBootTime() const;

  inline  ::uint32_t getEpisode() const;

  inline bool hasModelId() const;
  inline  ::capnp::Text::Reader getModelId() const;

  inline  ::uint32_t getFrameId() const;

  inline  ::cereal::StarPilotModelDataV2::VisionObservation::Stream getStream() 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 StarPilotModelDataV2::VisionObservation::Builder {
public:
  typedef VisionObservation 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 hasProducerSessionId();
  inline  ::capnp::Text::Builder getProducerSessionId();
  inline void setProducerSessionId( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initProducerSessionId(unsigned int size);
  inline void adoptProducerSessionId(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownProducerSessionId();

  inline  ::cereal::StarPilotModelDataV2::VisionObservation::Status getStatus();
  inline void setStatus( ::cereal::StarPilotModelDataV2::VisionObservation::Status value);

  inline float getSpeedMps();
  inline void setSpeedMps(float value);

  inline float getConfidence();
  inline void setConfidence(float value);

  inline  ::uint16_t getSupportCount();
  inline void setSupportCount( ::uint16_t value);

  inline  ::uint64_t getObservedMonoTime();
  inline void setObservedMonoTime( ::uint64_t value);

  inline  ::uint64_t getValidUntilMonoTime();
  inline void setValidUntilMonoTime( ::uint64_t value);

  inline  ::uint64_t getCameraFrameEofBootTime();
  inline void setCameraFrameEofBootTime( ::uint64_t value);

  inline  ::uint32_t getEpisode();
  inline void setEpisode( ::uint32_t value);

  inline bool hasModelId();
  inline  ::capnp::Text::Builder getModelId();
  inline void setModelId( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initModelId(unsigned int size);
  inline void adoptModelId(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownModelId();

  inline  ::uint32_t getFrameId();
  inline void setFrameId( ::uint32_t value);

  inline  ::cereal::StarPilotModelDataV2::VisionObservation::Stream getStream();
  inline void setStream( ::cereal::StarPilotModelDataV2::VisionObservation::Stream 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 StarPilotModelDataV2::VisionObservation::Pipeline {
public:
  typedef VisionObservation 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 StarPilotSteeringTracking::Reader {
public:
  typedef StarPilotSteeringTracking 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  ::uint16_t getVersion() const;

  inline bool hasSourceReceipt() const;
  inline  ::cereal::AutomaticLearningSourceReceipt::Reader getSourceReceipt() const;

  inline bool hasTrial() const;
  inline  ::cereal::LiveTrackingTrial::Reader getTrial() const;

  inline bool hasRestore() const;
  inline  ::cereal::LiveTrackingRestore::Reader getRestore() 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 StarPilotSteeringTracking::Builder {
public:
  typedef StarPilotSteeringTracking 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  ::uint16_t getVersion();
  inline void setVersion( ::uint16_t value);

  inline bool hasSourceReceipt();
  inline  ::cereal::AutomaticLearningSourceReceipt::Builder getSourceReceipt();
  inline void setSourceReceipt( ::cereal::AutomaticLearningSourceReceipt::Reader value);
  inline  ::cereal::AutomaticLearningSourceReceipt::Builder initSourceReceipt();
  inline void adoptSourceReceipt(::capnp::Orphan< ::cereal::AutomaticLearningSourceReceipt>&& value);
  inline ::capnp::Orphan< ::cereal::AutomaticLearningSourceReceipt> disownSourceReceipt();

  inline bool hasTrial();
  inline  ::cereal::LiveTrackingTrial::Builder getTrial();
  inline void setTrial( ::cereal::LiveTrackingTrial::Reader value);
  inline  ::cereal::LiveTrackingTrial::Builder initTrial();
  inline void adoptTrial(::capnp::Orphan< ::cereal::LiveTrackingTrial>&& value);
  inline ::capnp::Orphan< ::cereal::LiveTrackingTrial> disownTrial();

  inline bool hasRestore();
  inline  ::cereal::LiveTrackingRestore::Builder getRestore();
  inline void setRestore( ::cereal::LiveTrackingRestore::Reader value);
  inline  ::cereal::LiveTrackingRestore::Builder initRestore();
  inline void adoptRestore(::capnp::Orphan< ::cereal::LiveTrackingRestore>&& value);
  inline ::capnp::Orphan< ::cereal::LiveTrackingRestore> disownRestore();

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 StarPilotSteeringTracking::Pipeline {
public:
  typedef StarPilotSteeringTracking Pipelines;

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

  inline  ::cereal::AutomaticLearningSourceReceipt::Pipeline getSourceReceipt();
  inline  ::cereal::LiveTrackingTrial::Pipeline getTrial();
  inline  ::cereal::LiveTrackingRestore::Pipeline getRestore();
private:
  ::capnp::AnyPointer::Pipeline _typeless;
  friend class ::capnp::PipelineHook;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
};
#endif  // !CAPNP_LITE

class CustomReserved6::Reader {
public:
  typedef CustomReserved6 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 float getAccelerationJerk() const;

  inline bool getCscControllingSpeed() const;

  inline float getCscSpeed() const;

  inline bool getCscTraining() const;

  inline float getDangerFactor() const;

  inline float getDangerJerk() const;

  inline  ::int64_t getDesiredFollowDistance() const;

  inline bool getExperimentalMode() const;

  inline bool getForcingStop() const;

  inline float getForcingStopLength() const;

  inline bool hasStarpilotEvents() const;
  inline ::capnp::AnyPointer::Reader getStarpilotEvents() const;

  inline bool hasStarpilotToggles() const;
  inline  ::capnp::Text::Reader getStarpilotToggles() const;

  inline float getIncreasedStoppedDistance() const;

  inline bool getLateralCheck() const;

  inline float getLaneWidthLeft() const;

  inline float getLaneWidthRight() const;

  inline float getMaxAcceleration() const;

  inline float getMinAcceleration() const;

  inline bool getRedLight() const;

  inline float getRoadCurvature() const;

  inline float getSlcMapSpeedLimit() const;

  inline float getSlcMapboxSpeedLimit() const;

  inline float getSlcNextSpeedLimit() const;

  inline float getSlcOverriddenSpeed() const;

  inline float getSlcSpeedLimit() const;

  inline float getSlcSpeedLimitOffset() const;

  inline bool hasSlcSpeedLimitSource() const;
  inline  ::capnp::Text::Reader getSlcSpeedLimitSource() 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 CustomReserved6::Builder {
public:
  typedef CustomReserved6 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 float getAccelerationJerk();
  inline void setAccelerationJerk(float value);

  inline bool getCscControllingSpeed();
  inline void setCscControllingSpeed(bool value);

  inline float getCscSpeed();
  inline void setCscSpeed(float value);

  inline bool getCscTraining();
  inline void setCscTraining(bool value);

  inline float getDangerFactor();
  inline void setDangerFactor(float value);

  inline float getDangerJerk();
  inline void setDangerJerk(float value);

  inline  ::int64_t getDesiredFollowDistance();
  inline void setDesiredFollowDistance( ::int64_t value);

  inline bool getExperimentalMode();
  inline void setExperimentalMode(bool value);

  inline bool getForcingStop();
  inline void setForcingStop(bool value);

  inline float getForcingStopLength();
  inline void setForcingStopLength(float value);

  inline bool hasStarpilotEvents();
  inline ::capnp::AnyPointer::Builder getStarpilotEvents();
  inline ::capnp::AnyPointer::Builder initStarpilotEvents();

  inline bool hasStarpilotToggles();
  inline  ::capnp::Text::Builder getStarpilotToggles();
  inline void setStarpilotToggles( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initStarpilotToggles(unsigned int size);
  inline void adoptStarpilotToggles(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownStarpilotToggles();

  inline float getIncreasedStoppedDistance();
  inline void setIncreasedStoppedDistance(float value);

  inline bool getLateralCheck();
  inline void setLateralCheck(bool value);

  inline float getLaneWidthLeft();
  inline void setLaneWidthLeft(float value);

  inline float getLaneWidthRight();
  inline void setLaneWidthRight(float value);

  inline float getMaxAcceleration();
  inline void setMaxAcceleration(float value);

  inline float getMinAcceleration();
  inline void setMinAcceleration(float value);

  inline bool getRedLight();
  inline void setRedLight(bool value);

  inline float getRoadCurvature();
  inline void setRoadCurvature(float value);

  inline float getSlcMapSpeedLimit();
  inline void setSlcMapSpeedLimit(float value);

  inline float getSlcMapboxSpeedLimit();
  inline void setSlcMapboxSpeedLimit(float value);

  inline float getSlcNextSpeedLimit();
  inline void setSlcNextSpeedLimit(float value);

  inline float getSlcOverriddenSpeed();
  inline void setSlcOverriddenSpeed(float value);

  inline float getSlcSpeedLimit();
  inline void setSlcSpeedLimit(float value);

  inline float getSlcSpeedLimitOffset();
  inline void setSlcSpeedLimitOffset(float value);

  inline bool hasSlcSpeedLimitSource();
  inline  ::capnp::Text::Builder getSlcSpeedLimitSource();
  inline void setSlcSpeedLimitSource( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initSlcSpeedLimitSource(unsigned int size);
  inline void adoptSlcSpeedLimitSource(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownSlcSpeedLimitSource();

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 CustomReserved6::Pipeline {
public:
  typedef CustomReserved6 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 StarPilotRadarState::Reader {
public:
  typedef StarPilotRadarState 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 hasLeadLeft() const;
  inline  ::cereal::StarPilotRadarState::LeadData::Reader getLeadLeft() const;

  inline bool hasLeadRight() const;
  inline  ::cereal::StarPilotRadarState::LeadData::Reader getLeadRight() const;

  inline bool hasAdjacentStopped() const;
  inline  ::cereal::StarPilotRadarState::AdjacentStopped::Reader getAdjacentStopped() const;

  inline bool hasQualifiedAdjacent() const;
  inline  ::cereal::StarPilotRadarState::QualifiedAdjacent::Reader getQualifiedAdjacent() 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 StarPilotRadarState::Builder {
public:
  typedef StarPilotRadarState 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 hasLeadLeft();
  inline  ::cereal::StarPilotRadarState::LeadData::Builder getLeadLeft();
  inline void setLeadLeft( ::cereal::StarPilotRadarState::LeadData::Reader value);
  inline  ::cereal::StarPilotRadarState::LeadData::Builder initLeadLeft();
  inline void adoptLeadLeft(::capnp::Orphan< ::cereal::StarPilotRadarState::LeadData>&& value);
  inline ::capnp::Orphan< ::cereal::StarPilotRadarState::LeadData> disownLeadLeft();

  inline bool hasLeadRight();
  inline  ::cereal::StarPilotRadarState::LeadData::Builder getLeadRight();
  inline void setLeadRight( ::cereal::StarPilotRadarState::LeadData::Reader value);
  inline  ::cereal::StarPilotRadarState::LeadData::Builder initLeadRight();
  inline void adoptLeadRight(::capnp::Orphan< ::cereal::StarPilotRadarState::LeadData>&& value);
  inline ::capnp::Orphan< ::cereal::StarPilotRadarState::LeadData> disownLeadRight();

  inline bool hasAdjacentStopped();
  inline  ::cereal::StarPilotRadarState::AdjacentStopped::Builder getAdjacentStopped();
  inline void setAdjacentStopped( ::cereal::StarPilotRadarState::AdjacentStopped::Reader value);
  inline  ::cereal::StarPilotRadarState::AdjacentStopped::Builder initAdjacentStopped();
  inline void adoptAdjacentStopped(::capnp::Orphan< ::cereal::StarPilotRadarState::AdjacentStopped>&& value);
  inline ::capnp::Orphan< ::cereal::StarPilotRadarState::AdjacentStopped> disownAdjacentStopped();

  inline bool hasQualifiedAdjacent();
  inline  ::cereal::StarPilotRadarState::QualifiedAdjacent::Builder getQualifiedAdjacent();
  inline void setQualifiedAdjacent( ::cereal::StarPilotRadarState::QualifiedAdjacent::Reader value);
  inline  ::cereal::StarPilotRadarState::QualifiedAdjacent::Builder initQualifiedAdjacent();
  inline void adoptQualifiedAdjacent(::capnp::Orphan< ::cereal::StarPilotRadarState::QualifiedAdjacent>&& value);
  inline ::capnp::Orphan< ::cereal::StarPilotRadarState::QualifiedAdjacent> disownQualifiedAdjacent();

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 StarPilotRadarState::Pipeline {
public:
  typedef StarPilotRadarState Pipelines;

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

  inline  ::cereal::StarPilotRadarState::LeadData::Pipeline getLeadLeft();
  inline  ::cereal::StarPilotRadarState::LeadData::Pipeline getLeadRight();
  inline  ::cereal::StarPilotRadarState::AdjacentStopped::Pipeline getAdjacentStopped();
  inline  ::cereal::StarPilotRadarState::QualifiedAdjacent::Pipeline getQualifiedAdjacent();
private:
  ::capnp::AnyPointer::Pipeline _typeless;
  friend class ::capnp::PipelineHook;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
};
#endif  // !CAPNP_LITE

class StarPilotRadarState::AdjacentStopped::Reader {
public:
  typedef AdjacentStopped 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 getStatus() const;

  inline float getDRel() const;

  inline float getYRel() const;

  inline  ::int32_t getRadarTrackId() 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 StarPilotRadarState::AdjacentStopped::Builder {
public:
  typedef AdjacentStopped 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 getStatus();
  inline void setStatus(bool value);

  inline float getDRel();
  inline void setDRel(float value);

  inline float getYRel();
  inline void setYRel(float value);

  inline  ::int32_t getRadarTrackId();
  inline void setRadarTrackId( ::int32_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 StarPilotRadarState::AdjacentStopped::Pipeline {
public:
  typedef AdjacentStopped 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 StarPilotRadarState::LeadData::Reader {
public:
  typedef LeadData 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 float getDRel() const;

  inline float getYRel() const;

  inline float getVRel() const;

  inline float getARel() const;

  inline float getVLead() const;

  inline float getALeadDEPRECATED() const;

  inline float getDPath() const;

  inline float getVLat() const;

  inline float getVLeadK() const;

  inline float getALeadK() const;

  inline bool getFcw() const;

  inline bool getStatus() const;

  inline float getALeadTau() const;

  inline float getModelProb() const;

  inline bool getRadar() const;

  inline  ::int32_t getRadarTrackId() 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 StarPilotRadarState::LeadData::Builder {
public:
  typedef LeadData 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 float getDRel();
  inline void setDRel(float value);

  inline float getYRel();
  inline void setYRel(float value);

  inline float getVRel();
  inline void setVRel(float value);

  inline float getARel();
  inline void setARel(float value);

  inline float getVLead();
  inline void setVLead(float value);

  inline float getALeadDEPRECATED();
  inline void setALeadDEPRECATED(float value);

  inline float getDPath();
  inline void setDPath(float value);

  inline float getVLat();
  inline void setVLat(float value);

  inline float getVLeadK();
  inline void setVLeadK(float value);

  inline float getALeadK();
  inline void setALeadK(float value);

  inline bool getFcw();
  inline void setFcw(bool value);

  inline bool getStatus();
  inline void setStatus(bool value);

  inline float getALeadTau();
  inline void setALeadTau(float value);

  inline float getModelProb();
  inline void setModelProb(float value);

  inline bool getRadar();
  inline void setRadar(bool value);

  inline  ::int32_t getRadarTrackId();
  inline void setRadarTrackId( ::int32_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 StarPilotRadarState::LeadData::Pipeline {
public:
  typedef LeadData 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 StarPilotRadarState::QualifiedAdjacent::Reader {
public:
  typedef QualifiedAdjacent 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  ::uint16_t getVersion() const;

  inline  ::cereal::StarPilotRadarState::QualifiedAdjacent::Status getStatus() const;

  inline bool hasProducerSessionId() const;
  inline  ::capnp::Text::Reader getProducerSessionId() const;

  inline  ::uint64_t getSequence() const;

  inline  ::uint64_t getRadarTracksMonoTime() const;

  inline  ::uint64_t getModelMonoTime() const;

  inline  ::uint64_t getCarStateMonoTime() const;

  inline  ::uint64_t getCameraEofBootTime() const;

  inline  ::uint64_t getObservedMonoTime() const;

  inline  ::uint64_t getValidUntilMonoTime() const;

  inline bool hasLeft() const;
  inline  ::cereal::StarPilotRadarState::QualifiedAdjacent::Candidate::Reader getLeft() const;

  inline bool hasRight() const;
  inline  ::cereal::StarPilotRadarState::QualifiedAdjacent::Candidate::Reader getRight() 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 StarPilotRadarState::QualifiedAdjacent::Builder {
public:
  typedef QualifiedAdjacent 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  ::uint16_t getVersion();
  inline void setVersion( ::uint16_t value);

  inline  ::cereal::StarPilotRadarState::QualifiedAdjacent::Status getStatus();
  inline void setStatus( ::cereal::StarPilotRadarState::QualifiedAdjacent::Status value);

  inline bool hasProducerSessionId();
  inline  ::capnp::Text::Builder getProducerSessionId();
  inline void setProducerSessionId( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initProducerSessionId(unsigned int size);
  inline void adoptProducerSessionId(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownProducerSessionId();

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

  inline  ::uint64_t getRadarTracksMonoTime();
  inline void setRadarTracksMonoTime( ::uint64_t value);

  inline  ::uint64_t getModelMonoTime();
  inline void setModelMonoTime( ::uint64_t value);

  inline  ::uint64_t getCarStateMonoTime();
  inline void setCarStateMonoTime( ::uint64_t value);

  inline  ::uint64_t getCameraEofBootTime();
  inline void setCameraEofBootTime( ::uint64_t value);

  inline  ::uint64_t getObservedMonoTime();
  inline void setObservedMonoTime( ::uint64_t value);

  inline  ::uint64_t getValidUntilMonoTime();
  inline void setValidUntilMonoTime( ::uint64_t value);

  inline bool hasLeft();
  inline  ::cereal::StarPilotRadarState::QualifiedAdjacent::Candidate::Builder getLeft();
  inline void setLeft( ::cereal::StarPilotRadarState::QualifiedAdjacent::Candidate::Reader value);
  inline  ::cereal::StarPilotRadarState::QualifiedAdjacent::Candidate::Builder initLeft();
  inline void adoptLeft(::capnp::Orphan< ::cereal::StarPilotRadarState::QualifiedAdjacent::Candidate>&& value);
  inline ::capnp::Orphan< ::cereal::StarPilotRadarState::QualifiedAdjacent::Candidate> disownLeft();

  inline bool hasRight();
  inline  ::cereal::StarPilotRadarState::QualifiedAdjacent::Candidate::Builder getRight();
  inline void setRight( ::cereal::StarPilotRadarState::QualifiedAdjacent::Candidate::Reader value);
  inline  ::cereal::StarPilotRadarState::QualifiedAdjacent::Candidate::Builder initRight();
  inline void adoptRight(::capnp::Orphan< ::cereal::StarPilotRadarState::QualifiedAdjacent::Candidate>&& value);
  inline ::capnp::Orphan< ::cereal::StarPilotRadarState::QualifiedAdjacent::Candidate> disownRight();

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 StarPilotRadarState::QualifiedAdjacent::Pipeline {
public:
  typedef QualifiedAdjacent Pipelines;

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

  inline  ::cereal::StarPilotRadarState::QualifiedAdjacent::Candidate::Pipeline getLeft();
  inline  ::cereal::StarPilotRadarState::QualifiedAdjacent::Candidate::Pipeline getRight();
private:
  ::capnp::AnyPointer::Pipeline _typeless;
  friend class ::capnp::PipelineHook;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
};
#endif  // !CAPNP_LITE

class StarPilotRadarState::QualifiedAdjacent::Candidate::Reader {
public:
  typedef Candidate 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 getPresent() const;

  inline  ::uint32_t getTrackId() const;

  inline float getDistanceM() const;

  inline float getLateralM() const;

  inline float getSpeedMps() 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 StarPilotRadarState::QualifiedAdjacent::Candidate::Builder {
public:
  typedef Candidate 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 getPresent();
  inline void setPresent(bool value);

  inline  ::uint32_t getTrackId();
  inline void setTrackId( ::uint32_t value);

  inline float getDistanceM();
  inline void setDistanceM(float value);

  inline float getLateralM();
  inline void setLateralM(float value);

  inline float getSpeedMps();
  inline void setSpeedMps(float 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 StarPilotRadarState::QualifiedAdjacent::Candidate::Pipeline {
public:
  typedef Candidate 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 StarPilotSelfdriveState::Reader {
public:
  typedef StarPilotSelfdriveState 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 hasAlertText1() const;
  inline  ::capnp::Text::Reader getAlertText1() const;

  inline bool hasAlertText2() const;
  inline  ::capnp::Text::Reader getAlertText2() const;

  inline  ::cereal::StarPilotSelfdriveState::AlertStatus getAlertStatus() const;

  inline  ::cereal::StarPilotSelfdriveState::AlertSize getAlertSize() const;

  inline bool hasAlertType() const;
  inline  ::capnp::Text::Reader getAlertType() const;

  inline  ::cereal::CarControl::HUDControl::AudibleAlert getAlertSound() const;

  inline float getVEgo() const;

  inline bool hasConditionalModeAck() const;
  inline  ::cereal::StarPilotSelfdriveState::ConditionalModeAck::Reader getConditionalModeAck() 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 StarPilotSelfdriveState::Builder {
public:
  typedef StarPilotSelfdriveState 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 hasAlertText1();
  inline  ::capnp::Text::Builder getAlertText1();
  inline void setAlertText1( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initAlertText1(unsigned int size);
  inline void adoptAlertText1(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownAlertText1();

  inline bool hasAlertText2();
  inline  ::capnp::Text::Builder getAlertText2();
  inline void setAlertText2( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initAlertText2(unsigned int size);
  inline void adoptAlertText2(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownAlertText2();

  inline  ::cereal::StarPilotSelfdriveState::AlertStatus getAlertStatus();
  inline void setAlertStatus( ::cereal::StarPilotSelfdriveState::AlertStatus value);

  inline  ::cereal::StarPilotSelfdriveState::AlertSize getAlertSize();
  inline void setAlertSize( ::cereal::StarPilotSelfdriveState::AlertSize value);

  inline bool hasAlertType();
  inline  ::capnp::Text::Builder getAlertType();
  inline void setAlertType( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initAlertType(unsigned int size);
  inline void adoptAlertType(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownAlertType();

  inline  ::cereal::CarControl::HUDControl::AudibleAlert getAlertSound();
  inline void setAlertSound( ::cereal::CarControl::HUDControl::AudibleAlert value);

  inline float getVEgo();
  inline void setVEgo(float value);

  inline bool hasConditionalModeAck();
  inline  ::cereal::StarPilotSelfdriveState::ConditionalModeAck::Builder getConditionalModeAck();
  inline void setConditionalModeAck( ::cereal::StarPilotSelfdriveState::ConditionalModeAck::Reader value);
  inline  ::cereal::StarPilotSelfdriveState::ConditionalModeAck::Builder initConditionalModeAck();
  inline void adoptConditionalModeAck(::capnp::Orphan< ::cereal::StarPilotSelfdriveState::ConditionalModeAck>&& value);
  inline ::capnp::Orphan< ::cereal::StarPilotSelfdriveState::ConditionalModeAck> disownConditionalModeAck();

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 StarPilotSelfdriveState::Pipeline {
public:
  typedef StarPilotSelfdriveState Pipelines;

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

  inline  ::cereal::StarPilotSelfdriveState::ConditionalModeAck::Pipeline getConditionalModeAck();
private:
  ::capnp::AnyPointer::Pipeline _typeless;
  friend class ::capnp::PipelineHook;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
};
#endif  // !CAPNP_LITE

class StarPilotSelfdriveState::ConditionalModeAck::Reader {
public:
  typedef ConditionalModeAck 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  ::uint16_t getVersion() const;

  inline bool hasSessionId() const;
  inline  ::capnp::Text::Reader getSessionId() const;

  inline  ::uint64_t getSequence() const;

  inline  ::uint64_t getObservedMonoTime() const;

  inline  ::uint64_t getValidUntilMonoTime() const;

  inline  ::uint64_t getSourceSelfdriveStateMonoTime() const;

  inline  ::uint64_t getDriveStartMonoTime() const;

  inline  ::cereal::SlcState::ConditionalModeState::Choice getChoice() const;

  inline bool getAccepted() const;

  inline bool getEffectiveExperimental() const;

  inline bool hasPlannerSessionId() const;
  inline  ::capnp::Text::Reader getPlannerSessionId() const;

  inline  ::uint64_t getPlannerSequence() const;

  inline bool hasSettingsFingerprint() const;
  inline  ::capnp::Text::Reader getSettingsFingerprint() const;

  inline  ::uint64_t getSettingsRevision() const;

  inline  ::uint64_t getModelMonoTime() const;

  inline bool hasReason() const;
  inline  ::capnp::Text::Reader getReason() const;

  inline  ::uint16_t getStatusCode() 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 StarPilotSelfdriveState::ConditionalModeAck::Builder {
public:
  typedef ConditionalModeAck 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  ::uint16_t getVersion();
  inline void setVersion( ::uint16_t value);

  inline bool hasSessionId();
  inline  ::capnp::Text::Builder getSessionId();
  inline void setSessionId( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initSessionId(unsigned int size);
  inline void adoptSessionId(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownSessionId();

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

  inline  ::uint64_t getObservedMonoTime();
  inline void setObservedMonoTime( ::uint64_t value);

  inline  ::uint64_t getValidUntilMonoTime();
  inline void setValidUntilMonoTime( ::uint64_t value);

  inline  ::uint64_t getSourceSelfdriveStateMonoTime();
  inline void setSourceSelfdriveStateMonoTime( ::uint64_t value);

  inline  ::uint64_t getDriveStartMonoTime();
  inline void setDriveStartMonoTime( ::uint64_t value);

  inline  ::cereal::SlcState::ConditionalModeState::Choice getChoice();
  inline void setChoice( ::cereal::SlcState::ConditionalModeState::Choice value);

  inline bool getAccepted();
  inline void setAccepted(bool value);

  inline bool getEffectiveExperimental();
  inline void setEffectiveExperimental(bool value);

  inline bool hasPlannerSessionId();
  inline  ::capnp::Text::Builder getPlannerSessionId();
  inline void setPlannerSessionId( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initPlannerSessionId(unsigned int size);
  inline void adoptPlannerSessionId(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownPlannerSessionId();

  inline  ::uint64_t getPlannerSequence();
  inline void setPlannerSequence( ::uint64_t value);

  inline bool hasSettingsFingerprint();
  inline  ::capnp::Text::Builder getSettingsFingerprint();
  inline void setSettingsFingerprint( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initSettingsFingerprint(unsigned int size);
  inline void adoptSettingsFingerprint(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownSettingsFingerprint();

  inline  ::uint64_t getSettingsRevision();
  inline void setSettingsRevision( ::uint64_t value);

  inline  ::uint64_t getModelMonoTime();
  inline void setModelMonoTime( ::uint64_t value);

  inline bool hasReason();
  inline  ::capnp::Text::Builder getReason();
  inline void setReason( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initReason(unsigned int size);
  inline void adoptReason(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownReason();

  inline  ::uint16_t getStatusCode();
  inline void setStatusCode( ::uint16_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 StarPilotSelfdriveState::ConditionalModeAck::Pipeline {
public:
  typedef ConditionalModeAck 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 SpotMonitorState::Reader {
public:
  typedef SpotMonitorState 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 float getDesiredCurvature() const;

  inline bool hasObservation() const;
  inline  ::cereal::SpotMonitorState::Observation::Reader getObservation() 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 SpotMonitorState::Builder {
public:
  typedef SpotMonitorState 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 float getDesiredCurvature();
  inline void setDesiredCurvature(float value);

  inline bool hasObservation();
  inline  ::cereal::SpotMonitorState::Observation::Builder getObservation();
  inline void setObservation( ::cereal::SpotMonitorState::Observation::Reader value);
  inline  ::cereal::SpotMonitorState::Observation::Builder initObservation();
  inline void adoptObservation(::capnp::Orphan< ::cereal::SpotMonitorState::Observation>&& value);
  inline ::capnp::Orphan< ::cereal::SpotMonitorState::Observation> disownObservation();

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 SpotMonitorState::Pipeline {
public:
  typedef SpotMonitorState Pipelines;

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

  inline  ::cereal::SpotMonitorState::Observation::Pipeline getObservation();
private:
  ::capnp::AnyPointer::Pipeline _typeless;
  friend class ::capnp::PipelineHook;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
};
#endif  // !CAPNP_LITE

class SpotMonitorState::Observation::Reader {
public:
  typedef Observation 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  ::uint16_t getVersion() const;

  inline bool hasProducerSessionId() const;
  inline  ::capnp::Text::Reader getProducerSessionId() const;

  inline  ::uint64_t getSequence() const;

  inline bool hasModelSha256() const;
  inline  ::capnp::Text::Reader getModelSha256() const;

  inline bool hasSettingsFingerprint() const;
  inline  ::capnp::Text::Reader getSettingsFingerprint() const;

  inline  ::uint64_t getObservedMonoTime() const;

  inline  ::uint64_t getObservedBootTime() const;

  inline  ::uint64_t getSourceFrameId() const;

  inline  ::uint64_t getSourceFrameEofBootTime() const;

  inline  ::uint64_t getValidUntilBootTime() const;

  inline bool hasLeft() const;
  inline  ::cereal::SpotMonitorState::Observation::Side::Reader getLeft() const;

  inline bool hasRight() const;
  inline  ::cereal::SpotMonitorState::Observation::Side::Reader getRight() 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 SpotMonitorState::Observation::Builder {
public:
  typedef Observation 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  ::uint16_t getVersion();
  inline void setVersion( ::uint16_t value);

  inline bool hasProducerSessionId();
  inline  ::capnp::Text::Builder getProducerSessionId();
  inline void setProducerSessionId( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initProducerSessionId(unsigned int size);
  inline void adoptProducerSessionId(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownProducerSessionId();

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

  inline bool hasModelSha256();
  inline  ::capnp::Text::Builder getModelSha256();
  inline void setModelSha256( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initModelSha256(unsigned int size);
  inline void adoptModelSha256(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownModelSha256();

  inline bool hasSettingsFingerprint();
  inline  ::capnp::Text::Builder getSettingsFingerprint();
  inline void setSettingsFingerprint( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initSettingsFingerprint(unsigned int size);
  inline void adoptSettingsFingerprint(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownSettingsFingerprint();

  inline  ::uint64_t getObservedMonoTime();
  inline void setObservedMonoTime( ::uint64_t value);

  inline  ::uint64_t getObservedBootTime();
  inline void setObservedBootTime( ::uint64_t value);

  inline  ::uint64_t getSourceFrameId();
  inline void setSourceFrameId( ::uint64_t value);

  inline  ::uint64_t getSourceFrameEofBootTime();
  inline void setSourceFrameEofBootTime( ::uint64_t value);

  inline  ::uint64_t getValidUntilBootTime();
  inline void setValidUntilBootTime( ::uint64_t value);

  inline bool hasLeft();
  inline  ::cereal::SpotMonitorState::Observation::Side::Builder getLeft();
  inline void setLeft( ::cereal::SpotMonitorState::Observation::Side::Reader value);
  inline  ::cereal::SpotMonitorState::Observation::Side::Builder initLeft();
  inline void adoptLeft(::capnp::Orphan< ::cereal::SpotMonitorState::Observation::Side>&& value);
  inline ::capnp::Orphan< ::cereal::SpotMonitorState::Observation::Side> disownLeft();

  inline bool hasRight();
  inline  ::cereal::SpotMonitorState::Observation::Side::Builder getRight();
  inline void setRight( ::cereal::SpotMonitorState::Observation::Side::Reader value);
  inline  ::cereal::SpotMonitorState::Observation::Side::Builder initRight();
  inline void adoptRight(::capnp::Orphan< ::cereal::SpotMonitorState::Observation::Side>&& value);
  inline ::capnp::Orphan< ::cereal::SpotMonitorState::Observation::Side> disownRight();

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 SpotMonitorState::Observation::Pipeline {
public:
  typedef Observation Pipelines;

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

  inline  ::cereal::SpotMonitorState::Observation::Side::Pipeline getLeft();
  inline  ::cereal::SpotMonitorState::Observation::Side::Pipeline getRight();
private:
  ::capnp::AnyPointer::Pipeline _typeless;
  friend class ::capnp::PipelineHook;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
};
#endif  // !CAPNP_LITE

class SpotMonitorState::Observation::Side::Reader {
public:
  typedef Side 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  ::cereal::SpotMonitorState::Observation::Side::Status getStatus() const;

  inline float getConfidence() const;

  inline bool getWarning() const;

  inline  ::uint64_t getSourceFrameId() const;

  inline  ::uint64_t getSourceFrameEofBootTime() const;

  inline  ::uint64_t getSourceObservedMonoTime() const;

  inline  ::uint64_t getValidUntilBootTime() 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 SpotMonitorState::Observation::Side::Builder {
public:
  typedef Side 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  ::cereal::SpotMonitorState::Observation::Side::Status getStatus();
  inline void setStatus( ::cereal::SpotMonitorState::Observation::Side::Status value);

  inline float getConfidence();
  inline void setConfidence(float value);

  inline bool getWarning();
  inline void setWarning(bool value);

  inline  ::uint64_t getSourceFrameId();
  inline void setSourceFrameId( ::uint64_t value);

  inline  ::uint64_t getSourceFrameEofBootTime();
  inline void setSourceFrameEofBootTime( ::uint64_t value);

  inline  ::uint64_t getSourceObservedMonoTime();
  inline void setSourceObservedMonoTime( ::uint64_t value);

  inline  ::uint64_t getValidUntilBootTime();
  inline void setValidUntilBootTime( ::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 SpotMonitorState::Observation::Side::Pipeline {
public:
  typedef Side 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 StarPilotLateralState::Reader {
public:
  typedef StarPilotLateralState 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 getActive() const;

  inline float getFrictionThreshold() const;

  inline float getFrictionScale() const;

  inline float getFeedforward() const;

  inline float getFrictionJerk() const;

  inline float getFrictionJerkDeadzone() const;

  inline float getLowSpeedFactor() const;

  inline bool getUnwindDetected() const;

  inline bool hasLaneCentering() const;
  inline  ::cereal::StarPilotLateralState::LaneCentering::Reader getLaneCentering() const;

  inline bool hasLearningEvidence() const;
  inline  ::cereal::LearningControlEvidence::Reader getLearningEvidence() const;

  inline bool hasLearningApplication() const;
  inline  ::cereal::LearningApplication::Reader getLearningApplication() const;

  inline bool hasFeedbackConsumption() const;
  inline  ::cereal::StarPilotLateralState::FeedbackConsumption::Reader getFeedbackConsumption() const;

  inline bool hasTrackingApplication() const;
  inline  ::cereal::LiveTrackingApplication::Reader getTrackingApplication() 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 StarPilotLateralState::Builder {
public:
  typedef StarPilotLateralState 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 getActive();
  inline void setActive(bool value);

  inline float getFrictionThreshold();
  inline void setFrictionThreshold(float value);

  inline float getFrictionScale();
  inline void setFrictionScale(float value);

  inline float getFeedforward();
  inline void setFeedforward(float value);

  inline float getFrictionJerk();
  inline void setFrictionJerk(float value);

  inline float getFrictionJerkDeadzone();
  inline void setFrictionJerkDeadzone(float value);

  inline float getLowSpeedFactor();
  inline void setLowSpeedFactor(float value);

  inline bool getUnwindDetected();
  inline void setUnwindDetected(bool value);

  inline bool hasLaneCentering();
  inline  ::cereal::StarPilotLateralState::LaneCentering::Builder getLaneCentering();
  inline void setLaneCentering( ::cereal::StarPilotLateralState::LaneCentering::Reader value);
  inline  ::cereal::StarPilotLateralState::LaneCentering::Builder initLaneCentering();
  inline void adoptLaneCentering(::capnp::Orphan< ::cereal::StarPilotLateralState::LaneCentering>&& value);
  inline ::capnp::Orphan< ::cereal::StarPilotLateralState::LaneCentering> disownLaneCentering();

  inline bool hasLearningEvidence();
  inline  ::cereal::LearningControlEvidence::Builder getLearningEvidence();
  inline void setLearningEvidence( ::cereal::LearningControlEvidence::Reader value);
  inline  ::cereal::LearningControlEvidence::Builder initLearningEvidence();
  inline void adoptLearningEvidence(::capnp::Orphan< ::cereal::LearningControlEvidence>&& value);
  inline ::capnp::Orphan< ::cereal::LearningControlEvidence> disownLearningEvidence();

  inline bool hasLearningApplication();
  inline  ::cereal::LearningApplication::Builder getLearningApplication();
  inline void setLearningApplication( ::cereal::LearningApplication::Reader value);
  inline  ::cereal::LearningApplication::Builder initLearningApplication();
  inline void adoptLearningApplication(::capnp::Orphan< ::cereal::LearningApplication>&& value);
  inline ::capnp::Orphan< ::cereal::LearningApplication> disownLearningApplication();

  inline bool hasFeedbackConsumption();
  inline  ::cereal::StarPilotLateralState::FeedbackConsumption::Builder getFeedbackConsumption();
  inline void setFeedbackConsumption( ::cereal::StarPilotLateralState::FeedbackConsumption::Reader value);
  inline  ::cereal::StarPilotLateralState::FeedbackConsumption::Builder initFeedbackConsumption();
  inline void adoptFeedbackConsumption(::capnp::Orphan< ::cereal::StarPilotLateralState::FeedbackConsumption>&& value);
  inline ::capnp::Orphan< ::cereal::StarPilotLateralState::FeedbackConsumption> disownFeedbackConsumption();

  inline bool hasTrackingApplication();
  inline  ::cereal::LiveTrackingApplication::Builder getTrackingApplication();
  inline void setTrackingApplication( ::cereal::LiveTrackingApplication::Reader value);
  inline  ::cereal::LiveTrackingApplication::Builder initTrackingApplication();
  inline void adoptTrackingApplication(::capnp::Orphan< ::cereal::LiveTrackingApplication>&& value);
  inline ::capnp::Orphan< ::cereal::LiveTrackingApplication> disownTrackingApplication();

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 StarPilotLateralState::Pipeline {
public:
  typedef StarPilotLateralState Pipelines;

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

  inline  ::cereal::StarPilotLateralState::LaneCentering::Pipeline getLaneCentering();
  inline  ::cereal::LearningControlEvidence::Pipeline getLearningEvidence();
  inline  ::cereal::LearningApplication::Pipeline getLearningApplication();
  inline  ::cereal::StarPilotLateralState::FeedbackConsumption::Pipeline getFeedbackConsumption();
  inline  ::cereal::LiveTrackingApplication::Pipeline getTrackingApplication();
private:
  ::capnp::AnyPointer::Pipeline _typeless;
  friend class ::capnp::PipelineHook;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
};
#endif  // !CAPNP_LITE

class StarPilotLateralState::LaneCentering::Reader {
public:
  typedef LaneCentering 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  ::uint16_t getVersion() const;

  inline  ::uint64_t getModelMonoTime() const;

  inline  ::uint64_t getCarControlMonoTime() const;

  inline bool getLateralActive() const;

  inline float getRequestedCorrection() const;

  inline float getAppliedCorrection() const;

  inline bool hasReason() const;
  inline  ::capnp::Text::Reader getReason() 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 StarPilotLateralState::LaneCentering::Builder {
public:
  typedef LaneCentering 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  ::uint16_t getVersion();
  inline void setVersion( ::uint16_t value);

  inline  ::uint64_t getModelMonoTime();
  inline void setModelMonoTime( ::uint64_t value);

  inline  ::uint64_t getCarControlMonoTime();
  inline void setCarControlMonoTime( ::uint64_t value);

  inline bool getLateralActive();
  inline void setLateralActive(bool value);

  inline float getRequestedCorrection();
  inline void setRequestedCorrection(float value);

  inline float getAppliedCorrection();
  inline void setAppliedCorrection(float value);

  inline bool hasReason();
  inline  ::capnp::Text::Builder getReason();
  inline void setReason( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initReason(unsigned int size);
  inline void adoptReason(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownReason();

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 StarPilotLateralState::LaneCentering::Pipeline {
public:
  typedef LaneCentering 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 StarPilotLateralState::FeedbackConsumption::Reader {
public:
  typedef FeedbackConsumption 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  ::uint16_t getVersion() const;

  inline  ::uint64_t getControlMonoTime() const;

  inline  ::uint64_t getConsumedPublicationMonoTime() const;

  inline  ::uint64_t getConsumedRecvFrame() const;

  inline  ::uint64_t getConsumedReceiptMonoTime() const;

  inline bool getConsumedSeen() const;

  inline bool getConsumedValid() const;

  inline bool hasCoBodySha256() const;
  inline  ::capnp::Data::Reader getCoBodySha256() const;

  inline float getReportedTorque() const;

  inline float getRequestTorque() const;

  inline bool getLatActive() const;

  inline bool getInputSafetyLimited() const;

  inline bool getPublishedSafetyLimited() const;

  inline  ::uint64_t getPriorPublishControlMonoTime() const;

  inline bool hasSourceEpoch() const;
  inline  ::capnp::Text::Reader getSourceEpoch() const;

  inline bool hasCpSha256() const;
  inline  ::capnp::Text::Reader getCpSha256() 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 StarPilotLateralState::FeedbackConsumption::Builder {
public:
  typedef FeedbackConsumption 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  ::uint16_t getVersion();
  inline void setVersion( ::uint16_t value);

  inline  ::uint64_t getControlMonoTime();
  inline void setControlMonoTime( ::uint64_t value);

  inline  ::uint64_t getConsumedPublicationMonoTime();
  inline void setConsumedPublicationMonoTime( ::uint64_t value);

  inline  ::uint64_t getConsumedRecvFrame();
  inline void setConsumedRecvFrame( ::uint64_t value);

  inline  ::uint64_t getConsumedReceiptMonoTime();
  inline void setConsumedReceiptMonoTime( ::uint64_t value);

  inline bool getConsumedSeen();
  inline void setConsumedSeen(bool value);

  inline bool getConsumedValid();
  inline void setConsumedValid(bool value);

  inline bool hasCoBodySha256();
  inline  ::capnp::Data::Builder getCoBodySha256();
  inline void setCoBodySha256( ::capnp::Data::Reader value);
  inline  ::capnp::Data::Builder initCoBodySha256(unsigned int size);
  inline void adoptCoBodySha256(::capnp::Orphan< ::capnp::Data>&& value);
  inline ::capnp::Orphan< ::capnp::Data> disownCoBodySha256();

  inline float getReportedTorque();
  inline void setReportedTorque(float value);

  inline float getRequestTorque();
  inline void setRequestTorque(float value);

  inline bool getLatActive();
  inline void setLatActive(bool value);

  inline bool getInputSafetyLimited();
  inline void setInputSafetyLimited(bool value);

  inline bool getPublishedSafetyLimited();
  inline void setPublishedSafetyLimited(bool value);

  inline  ::uint64_t getPriorPublishControlMonoTime();
  inline void setPriorPublishControlMonoTime( ::uint64_t value);

  inline bool hasSourceEpoch();
  inline  ::capnp::Text::Builder getSourceEpoch();
  inline void setSourceEpoch( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initSourceEpoch(unsigned int size);
  inline void adoptSourceEpoch(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownSourceEpoch();

  inline bool hasCpSha256();
  inline  ::capnp::Text::Builder getCpSha256();
  inline void setCpSha256( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initCpSha256(unsigned int size);
  inline void adoptCpSha256(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownCpSha256();

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 StarPilotLateralState::FeedbackConsumption::Pipeline {
public:
  typedef FeedbackConsumption 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 SlcCruiseCommand::Reader {
public:
  typedef SlcCruiseCommand 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  ::cereal::SlcCruiseCommand::Kind getKind() const;

  inline bool hasSessionId() const;
  inline  ::capnp::Text::Reader getSessionId() const;

  inline  ::uint64_t getCommandId() const;

  inline  ::uint64_t getActionId() const;

  inline  ::uint64_t getDecisionId() const;

  inline  ::uint64_t getPresentationId() const;

  inline bool hasSourceProducerSessionId() const;
  inline  ::capnp::Text::Reader getSourceProducerSessionId() const;

  inline  ::uint32_t getSourceEpisode() const;

  inline  ::uint64_t getSourceObservedMonoTime() const;

  inline  ::uint64_t getSourceValidUntilMonoTime() const;

  inline  ::uint64_t getIssuedMonoTime() const;

  inline  ::uint64_t getExpiresMonoTime() const;

  inline float getExpectedSelectedMps() const;

  inline float getTargetMps() const;

  inline bool hasSource() const;
  inline  ::capnp::Text::Reader getSource() 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 SlcCruiseCommand::Builder {
public:
  typedef SlcCruiseCommand 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  ::cereal::SlcCruiseCommand::Kind getKind();
  inline void setKind( ::cereal::SlcCruiseCommand::Kind value);

  inline bool hasSessionId();
  inline  ::capnp::Text::Builder getSessionId();
  inline void setSessionId( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initSessionId(unsigned int size);
  inline void adoptSessionId(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownSessionId();

  inline  ::uint64_t getCommandId();
  inline void setCommandId( ::uint64_t value);

  inline  ::uint64_t getActionId();
  inline void setActionId( ::uint64_t value);

  inline  ::uint64_t getDecisionId();
  inline void setDecisionId( ::uint64_t value);

  inline  ::uint64_t getPresentationId();
  inline void setPresentationId( ::uint64_t value);

  inline bool hasSourceProducerSessionId();
  inline  ::capnp::Text::Builder getSourceProducerSessionId();
  inline void setSourceProducerSessionId( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initSourceProducerSessionId(unsigned int size);
  inline void adoptSourceProducerSessionId(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownSourceProducerSessionId();

  inline  ::uint32_t getSourceEpisode();
  inline void setSourceEpisode( ::uint32_t value);

  inline  ::uint64_t getSourceObservedMonoTime();
  inline void setSourceObservedMonoTime( ::uint64_t value);

  inline  ::uint64_t getSourceValidUntilMonoTime();
  inline void setSourceValidUntilMonoTime( ::uint64_t value);

  inline  ::uint64_t getIssuedMonoTime();
  inline void setIssuedMonoTime( ::uint64_t value);

  inline  ::uint64_t getExpiresMonoTime();
  inline void setExpiresMonoTime( ::uint64_t value);

  inline float getExpectedSelectedMps();
  inline void setExpectedSelectedMps(float value);

  inline float getTargetMps();
  inline void setTargetMps(float value);

  inline bool hasSource();
  inline  ::capnp::Text::Builder getSource();
  inline void setSource( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initSource(unsigned int size);
  inline void adoptSource(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownSource();

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 SlcCruiseCommand::Pipeline {
public:
  typedef SlcCruiseCommand 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 AolAxisState::Reader {
public:
  typedef AolAxisState 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 hasSessionId() const;
  inline  ::capnp::Text::Reader getSessionId() const;

  inline  ::uint64_t getSequence() const;

  inline  ::uint64_t getSourceCarStateMonoTime() const;

  inline  ::uint64_t getObservedMonoTime() const;

  inline  ::uint64_t getValidUntilMonoTime() const;

  inline  ::cereal::AolAxisState::Mode getMode() const;

  inline bool getLateralActive() const;

  inline bool getLongitudinalActive() const;

  inline bool getQualified() const;

  inline bool getDesiredLateral() const;

  inline bool getDesiredLongitudinal() const;

  inline bool getNativeAcknowledged() const;

  inline bool getOptionalSetRelease() const;

  inline  ::cereal::AolAxisState::FaultReason getFaultReason() const;

  inline  ::uint64_t getFaultEventMonoTime() const;

  inline bool hasFaultSessionId() const;
  inline  ::capnp::Text::Reader getFaultSessionId() const;

  inline bool hasIntentProducerSessionId() const;
  inline  ::capnp::Text::Reader getIntentProducerSessionId() const;

  inline  ::uint64_t getIntentIntegrityEpoch() 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 AolAxisState::Builder {
public:
  typedef AolAxisState 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 hasSessionId();
  inline  ::capnp::Text::Builder getSessionId();
  inline void setSessionId( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initSessionId(unsigned int size);
  inline void adoptSessionId(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownSessionId();

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

  inline  ::uint64_t getSourceCarStateMonoTime();
  inline void setSourceCarStateMonoTime( ::uint64_t value);

  inline  ::uint64_t getObservedMonoTime();
  inline void setObservedMonoTime( ::uint64_t value);

  inline  ::uint64_t getValidUntilMonoTime();
  inline void setValidUntilMonoTime( ::uint64_t value);

  inline  ::cereal::AolAxisState::Mode getMode();
  inline void setMode( ::cereal::AolAxisState::Mode value);

  inline bool getLateralActive();
  inline void setLateralActive(bool value);

  inline bool getLongitudinalActive();
  inline void setLongitudinalActive(bool value);

  inline bool getQualified();
  inline void setQualified(bool value);

  inline bool getDesiredLateral();
  inline void setDesiredLateral(bool value);

  inline bool getDesiredLongitudinal();
  inline void setDesiredLongitudinal(bool value);

  inline bool getNativeAcknowledged();
  inline void setNativeAcknowledged(bool value);

  inline bool getOptionalSetRelease();
  inline void setOptionalSetRelease(bool value);

  inline  ::cereal::AolAxisState::FaultReason getFaultReason();
  inline void setFaultReason( ::cereal::AolAxisState::FaultReason value);

  inline  ::uint64_t getFaultEventMonoTime();
  inline void setFaultEventMonoTime( ::uint64_t value);

  inline bool hasFaultSessionId();
  inline  ::capnp::Text::Builder getFaultSessionId();
  inline void setFaultSessionId( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initFaultSessionId(unsigned int size);
  inline void adoptFaultSessionId(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownFaultSessionId();

  inline bool hasIntentProducerSessionId();
  inline  ::capnp::Text::Builder getIntentProducerSessionId();
  inline void setIntentProducerSessionId( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initIntentProducerSessionId(unsigned int size);
  inline void adoptIntentProducerSessionId(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownIntentProducerSessionId();

  inline  ::uint64_t getIntentIntegrityEpoch();
  inline void setIntentIntegrityEpoch( ::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 AolAxisState::Pipeline {
public:
  typedef AolAxisState 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 AolAxisState::SafetyWire::Reader {
public:
  typedef SafetyWire 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  ::uint8_t getKind() const;

  inline  ::uint16_t getVersion() const;

  inline  ::uint16_t getProtocolVersion() const;

  inline bool getCompatible() const;

  inline  ::uint64_t getObservedMonoTime() const;

  inline  ::uint64_t getValidUntilMonoTime() const;

  inline  ::uint16_t getSafetyModel() const;

  inline  ::uint16_t getSafetyParam() const;

  inline bool getLateralAllowed() const;

  inline bool getLongitudinalAllowed() const;

  inline bool getRequestedLateral() const;

  inline bool getRequestedLongitudinal() const;

  inline bool hasPandaSerial() const;
  inline  ::capnp::Text::Reader getPandaSerial() const;

  inline bool hasAxisSessionId() const;
  inline  ::capnp::Text::Reader getAxisSessionId() const;

  inline  ::uint64_t getSourcePandaStatesMonoTime() const;

  inline bool hasPandaInventory() const;
  inline  ::capnp::List< ::cereal::AolAxisState::SafetyWire::PandaSlot,  ::capnp::Kind::STRUCT>::Reader getPandaInventory() 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 AolAxisState::SafetyWire::Builder {
public:
  typedef SafetyWire 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  ::uint8_t getKind();
  inline void setKind( ::uint8_t value);

  inline  ::uint16_t getVersion();
  inline void setVersion( ::uint16_t value);

  inline  ::uint16_t getProtocolVersion();
  inline void setProtocolVersion( ::uint16_t value);

  inline bool getCompatible();
  inline void setCompatible(bool value);

  inline  ::uint64_t getObservedMonoTime();
  inline void setObservedMonoTime( ::uint64_t value);

  inline  ::uint64_t getValidUntilMonoTime();
  inline void setValidUntilMonoTime( ::uint64_t value);

  inline  ::uint16_t getSafetyModel();
  inline void setSafetyModel( ::uint16_t value);

  inline  ::uint16_t getSafetyParam();
  inline void setSafetyParam( ::uint16_t value);

  inline bool getLateralAllowed();
  inline void setLateralAllowed(bool value);

  inline bool getLongitudinalAllowed();
  inline void setLongitudinalAllowed(bool value);

  inline bool getRequestedLateral();
  inline void setRequestedLateral(bool value);

  inline bool getRequestedLongitudinal();
  inline void setRequestedLongitudinal(bool value);

  inline bool hasPandaSerial();
  inline  ::capnp::Text::Builder getPandaSerial();
  inline void setPandaSerial( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initPandaSerial(unsigned int size);
  inline void adoptPandaSerial(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownPandaSerial();

  inline bool hasAxisSessionId();
  inline  ::capnp::Text::Builder getAxisSessionId();
  inline void setAxisSessionId( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initAxisSessionId(unsigned int size);
  inline void adoptAxisSessionId(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownAxisSessionId();

  inline  ::uint64_t getSourcePandaStatesMonoTime();
  inline void setSourcePandaStatesMonoTime( ::uint64_t value);

  inline bool hasPandaInventory();
  inline  ::capnp::List< ::cereal::AolAxisState::SafetyWire::PandaSlot,  ::capnp::Kind::STRUCT>::Builder getPandaInventory();
  inline void setPandaInventory( ::capnp::List< ::cereal::AolAxisState::SafetyWire::PandaSlot,  ::capnp::Kind::STRUCT>::Reader value);
  inline  ::capnp::List< ::cereal::AolAxisState::SafetyWire::PandaSlot,  ::capnp::Kind::STRUCT>::Builder initPandaInventory(unsigned int size);
  inline void adoptPandaInventory(::capnp::Orphan< ::capnp::List< ::cereal::AolAxisState::SafetyWire::PandaSlot,  ::capnp::Kind::STRUCT>>&& value);
  inline ::capnp::Orphan< ::capnp::List< ::cereal::AolAxisState::SafetyWire::PandaSlot,  ::capnp::Kind::STRUCT>> disownPandaInventory();

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 AolAxisState::SafetyWire::Pipeline {
public:
  typedef SafetyWire 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 AolAxisState::SafetyWire::PandaSlot::Reader {
public:
  typedef PandaSlot 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  ::uint16_t getSlotIndex() const;

  inline bool hasHardwareSerial() const;
  inline  ::capnp::Text::Reader getHardwareSerial() const;

  inline  ::uint16_t getSafetyModel() const;

  inline  ::uint16_t getSafetyParam() const;

  inline  ::uint16_t getAlternativeExperience() const;

  inline bool getControlsAllowed() const;

  inline bool getSafetyRxChecksInvalid() const;

  inline bool getHeartbeatLost() const;

  inline  ::uint32_t getFaults() 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 AolAxisState::SafetyWire::PandaSlot::Builder {
public:
  typedef PandaSlot 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  ::uint16_t getSlotIndex();
  inline void setSlotIndex( ::uint16_t value);

  inline bool hasHardwareSerial();
  inline  ::capnp::Text::Builder getHardwareSerial();
  inline void setHardwareSerial( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initHardwareSerial(unsigned int size);
  inline void adoptHardwareSerial(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownHardwareSerial();

  inline  ::uint16_t getSafetyModel();
  inline void setSafetyModel( ::uint16_t value);

  inline  ::uint16_t getSafetyParam();
  inline void setSafetyParam( ::uint16_t value);

  inline  ::uint16_t getAlternativeExperience();
  inline void setAlternativeExperience( ::uint16_t value);

  inline bool getControlsAllowed();
  inline void setControlsAllowed(bool value);

  inline bool getSafetyRxChecksInvalid();
  inline void setSafetyRxChecksInvalid(bool value);

  inline bool getHeartbeatLost();
  inline void setHeartbeatLost(bool value);

  inline  ::uint32_t getFaults();
  inline void setFaults( ::uint32_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 AolAxisState::SafetyWire::PandaSlot::Pipeline {
public:
  typedef PandaSlot 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 AolAxisState::IntentWire::Reader {
public:
  typedef IntentWire 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  ::uint8_t getKind() const;

  inline  ::uint16_t getVersion() const;

  inline bool hasProducerSessionId() const;
  inline  ::capnp::Text::Reader getProducerSessionId() const;

  inline  ::uint64_t getSequence() const;

  inline  ::uint64_t getCarStateLogMonoTime() const;

  inline  ::uint64_t getObservedMonoTime() const;

  inline  ::uint64_t getValidUntilMonoTime() const;

  inline bool getAllowedLatch() const;

  inline bool getPauseLateral() const;

  inline bool getPauseLongitudinal() const;

  inline bool getSettingsQualified() const;

  inline bool getLateralArmed() const;

  inline bool getOptionalSetRelease() 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 AolAxisState::IntentWire::Builder {
public:
  typedef IntentWire 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  ::uint8_t getKind();
  inline void setKind( ::uint8_t value);

  inline  ::uint16_t getVersion();
  inline void setVersion( ::uint16_t value);

  inline bool hasProducerSessionId();
  inline  ::capnp::Text::Builder getProducerSessionId();
  inline void setProducerSessionId( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initProducerSessionId(unsigned int size);
  inline void adoptProducerSessionId(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownProducerSessionId();

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

  inline  ::uint64_t getCarStateLogMonoTime();
  inline void setCarStateLogMonoTime( ::uint64_t value);

  inline  ::uint64_t getObservedMonoTime();
  inline void setObservedMonoTime( ::uint64_t value);

  inline  ::uint64_t getValidUntilMonoTime();
  inline void setValidUntilMonoTime( ::uint64_t value);

  inline bool getAllowedLatch();
  inline void setAllowedLatch(bool value);

  inline bool getPauseLateral();
  inline void setPauseLateral(bool value);

  inline bool getPauseLongitudinal();
  inline void setPauseLongitudinal(bool value);

  inline bool getSettingsQualified();
  inline void setSettingsQualified(bool value);

  inline bool getLateralArmed();
  inline void setLateralArmed(bool value);

  inline bool getOptionalSetRelease();
  inline void setOptionalSetRelease(bool 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 AolAxisState::IntentWire::Pipeline {
public:
  typedef IntentWire 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 AolAxisState::LaneChangeStatusWire::Reader {
public:
  typedef LaneChangeStatusWire 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  ::uint8_t getKind() const;

  inline  ::uint16_t getVersion() const;

  inline bool hasProducerSessionId() const;
  inline  ::capnp::Text::Reader getProducerSessionId() const;

  inline  ::uint64_t getSequence() const;

  inline  ::uint32_t getModelFrameId() const;

  inline  ::uint64_t getModelTimestampEofNs() const;

  inline  ::uint64_t getObservedMonoTimeNs() const;

  inline  ::uint64_t getValidUntilMonoTimeNs() const;

  inline  ::cereal::AolAxisState::LaneChangeStatusWire::Phase getPhase() const;

  inline  ::cereal::AolAxisState::LaneChangeStatusWire::Direction getDirection() const;

  inline bool getAutoConfigured() const;

  inline bool getEngaged() 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 AolAxisState::LaneChangeStatusWire::Builder {
public:
  typedef LaneChangeStatusWire 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  ::uint8_t getKind();
  inline void setKind( ::uint8_t value);

  inline  ::uint16_t getVersion();
  inline void setVersion( ::uint16_t value);

  inline bool hasProducerSessionId();
  inline  ::capnp::Text::Builder getProducerSessionId();
  inline void setProducerSessionId( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initProducerSessionId(unsigned int size);
  inline void adoptProducerSessionId(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownProducerSessionId();

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

  inline  ::uint32_t getModelFrameId();
  inline void setModelFrameId( ::uint32_t value);

  inline  ::uint64_t getModelTimestampEofNs();
  inline void setModelTimestampEofNs( ::uint64_t value);

  inline  ::uint64_t getObservedMonoTimeNs();
  inline void setObservedMonoTimeNs( ::uint64_t value);

  inline  ::uint64_t getValidUntilMonoTimeNs();
  inline void setValidUntilMonoTimeNs( ::uint64_t value);

  inline  ::cereal::AolAxisState::LaneChangeStatusWire::Phase getPhase();
  inline void setPhase( ::cereal::AolAxisState::LaneChangeStatusWire::Phase value);

  inline  ::cereal::AolAxisState::LaneChangeStatusWire::Direction getDirection();
  inline void setDirection( ::cereal::AolAxisState::LaneChangeStatusWire::Direction value);

  inline bool getAutoConfigured();
  inline void setAutoConfigured(bool value);

  inline bool getEngaged();
  inline void setEngaged(bool 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 AolAxisState::LaneChangeStatusWire::Pipeline {
public:
  typedef LaneChangeStatusWire 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 MapdExtendedOut::Reader {
public:
  typedef MapdExtendedOut 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 hasDownloadProgress() const;
  inline  ::cereal::MapdExtendedOut::MapdDownloadProgress::Reader getDownloadProgress() const;

  inline bool hasSettings() const;
  inline  ::capnp::Text::Reader getSettings() const;

  inline bool hasPath() const;
  inline  ::capnp::List< ::cereal::MapdExtendedOut::MapdPathPoint,  ::capnp::Kind::STRUCT>::Reader getPath() const;

  inline bool hasPosition() const;
  inline  ::cereal::MapdExtendedOut::MapdPosition::Reader getPosition() const;

  inline float getLoopRateAverage() const;

  inline float getLoopRateMin() 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 MapdExtendedOut::Builder {
public:
  typedef MapdExtendedOut 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 hasDownloadProgress();
  inline  ::cereal::MapdExtendedOut::MapdDownloadProgress::Builder getDownloadProgress();
  inline void setDownloadProgress( ::cereal::MapdExtendedOut::MapdDownloadProgress::Reader value);
  inline  ::cereal::MapdExtendedOut::MapdDownloadProgress::Builder initDownloadProgress();
  inline void adoptDownloadProgress(::capnp::Orphan< ::cereal::MapdExtendedOut::MapdDownloadProgress>&& value);
  inline ::capnp::Orphan< ::cereal::MapdExtendedOut::MapdDownloadProgress> disownDownloadProgress();

  inline bool hasSettings();
  inline  ::capnp::Text::Builder getSettings();
  inline void setSettings( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initSettings(unsigned int size);
  inline void adoptSettings(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownSettings();

  inline bool hasPath();
  inline  ::capnp::List< ::cereal::MapdExtendedOut::MapdPathPoint,  ::capnp::Kind::STRUCT>::Builder getPath();
  inline void setPath( ::capnp::List< ::cereal::MapdExtendedOut::MapdPathPoint,  ::capnp::Kind::STRUCT>::Reader value);
  inline  ::capnp::List< ::cereal::MapdExtendedOut::MapdPathPoint,  ::capnp::Kind::STRUCT>::Builder initPath(unsigned int size);
  inline void adoptPath(::capnp::Orphan< ::capnp::List< ::cereal::MapdExtendedOut::MapdPathPoint,  ::capnp::Kind::STRUCT>>&& value);
  inline ::capnp::Orphan< ::capnp::List< ::cereal::MapdExtendedOut::MapdPathPoint,  ::capnp::Kind::STRUCT>> disownPath();

  inline bool hasPosition();
  inline  ::cereal::MapdExtendedOut::MapdPosition::Builder getPosition();
  inline void setPosition( ::cereal::MapdExtendedOut::MapdPosition::Reader value);
  inline  ::cereal::MapdExtendedOut::MapdPosition::Builder initPosition();
  inline void adoptPosition(::capnp::Orphan< ::cereal::MapdExtendedOut::MapdPosition>&& value);
  inline ::capnp::Orphan< ::cereal::MapdExtendedOut::MapdPosition> disownPosition();

  inline float getLoopRateAverage();
  inline void setLoopRateAverage(float value);

  inline float getLoopRateMin();
  inline void setLoopRateMin(float 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 MapdExtendedOut::Pipeline {
public:
  typedef MapdExtendedOut Pipelines;

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

  inline  ::cereal::MapdExtendedOut::MapdDownloadProgress::Pipeline getDownloadProgress();
  inline  ::cereal::MapdExtendedOut::MapdPosition::Pipeline getPosition();
private:
  ::capnp::AnyPointer::Pipeline _typeless;
  friend class ::capnp::PipelineHook;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
};
#endif  // !CAPNP_LITE

class MapdExtendedOut::MapdDownloadLocationDetails::Reader {
public:
  typedef MapdDownloadLocationDetails 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 hasLocation() const;
  inline  ::capnp::Text::Reader getLocation() const;

  inline  ::uint32_t getTotalFiles() const;

  inline  ::uint32_t getDownloadedFiles() 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 MapdExtendedOut::MapdDownloadLocationDetails::Builder {
public:
  typedef MapdDownloadLocationDetails 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 hasLocation();
  inline  ::capnp::Text::Builder getLocation();
  inline void setLocation( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initLocation(unsigned int size);
  inline void adoptLocation(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownLocation();

  inline  ::uint32_t getTotalFiles();
  inline void setTotalFiles( ::uint32_t value);

  inline  ::uint32_t getDownloadedFiles();
  inline void setDownloadedFiles( ::uint32_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 MapdExtendedOut::MapdDownloadLocationDetails::Pipeline {
public:
  typedef MapdDownloadLocationDetails 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 MapdExtendedOut::MapdDownloadProgress::Reader {
public:
  typedef MapdDownloadProgress 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 getActive() const;

  inline bool getCancelled() const;

  inline  ::uint32_t getTotalFiles() const;

  inline  ::uint32_t getDownloadedFiles() const;

  inline bool hasLocations() const;
  inline  ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>::Reader getLocations() const;

  inline bool hasLocationDetails() const;
  inline  ::capnp::List< ::cereal::MapdExtendedOut::MapdDownloadLocationDetails,  ::capnp::Kind::STRUCT>::Reader getLocationDetails() 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 MapdExtendedOut::MapdDownloadProgress::Builder {
public:
  typedef MapdDownloadProgress 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 getActive();
  inline void setActive(bool value);

  inline bool getCancelled();
  inline void setCancelled(bool value);

  inline  ::uint32_t getTotalFiles();
  inline void setTotalFiles( ::uint32_t value);

  inline  ::uint32_t getDownloadedFiles();
  inline void setDownloadedFiles( ::uint32_t value);

  inline bool hasLocations();
  inline  ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>::Builder getLocations();
  inline void setLocations( ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>::Reader value);
  inline void setLocations(::kj::ArrayPtr<const  ::capnp::Text::Reader> value);
  inline  ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>::Builder initLocations(unsigned int size);
  inline void adoptLocations(::capnp::Orphan< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>&& value);
  inline ::capnp::Orphan< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>> disownLocations();

  inline bool hasLocationDetails();
  inline  ::capnp::List< ::cereal::MapdExtendedOut::MapdDownloadLocationDetails,  ::capnp::Kind::STRUCT>::Builder getLocationDetails();
  inline void setLocationDetails( ::capnp::List< ::cereal::MapdExtendedOut::MapdDownloadLocationDetails,  ::capnp::Kind::STRUCT>::Reader value);
  inline  ::capnp::List< ::cereal::MapdExtendedOut::MapdDownloadLocationDetails,  ::capnp::Kind::STRUCT>::Builder initLocationDetails(unsigned int size);
  inline void adoptLocationDetails(::capnp::Orphan< ::capnp::List< ::cereal::MapdExtendedOut::MapdDownloadLocationDetails,  ::capnp::Kind::STRUCT>>&& value);
  inline ::capnp::Orphan< ::capnp::List< ::cereal::MapdExtendedOut::MapdDownloadLocationDetails,  ::capnp::Kind::STRUCT>> disownLocationDetails();

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 MapdExtendedOut::MapdDownloadProgress::Pipeline {
public:
  typedef MapdDownloadProgress 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 MapdExtendedOut::MapdPathPoint::Reader {
public:
  typedef MapdPathPoint 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 double getLatitude() const;

  inline double getLongitude() const;

  inline float getCurvature() const;

  inline float getTargetVelocity() 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 MapdExtendedOut::MapdPathPoint::Builder {
public:
  typedef MapdPathPoint 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 double getLatitude();
  inline void setLatitude(double value);

  inline double getLongitude();
  inline void setLongitude(double value);

  inline float getCurvature();
  inline void setCurvature(float value);

  inline float getTargetVelocity();
  inline void setTargetVelocity(float 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 MapdExtendedOut::MapdPathPoint::Pipeline {
public:
  typedef MapdPathPoint 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 MapdExtendedOut::MapdPosition::Reader {
public:
  typedef MapdPosition 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 double getLatitude() const;

  inline double getLongitude() 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 MapdExtendedOut::MapdPosition::Builder {
public:
  typedef MapdPosition 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 double getLatitude();
  inline void setLatitude(double value);

  inline double getLongitude();
  inline void setLongitude(double 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 MapdExtendedOut::MapdPosition::Pipeline {
public:
  typedef MapdPosition 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 MapdIn::Reader {
public:
  typedef MapdIn 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  ::cereal::MapdIn::MapdInputType getType() const;

  inline float getFloat() const;

  inline bool hasStr() const;
  inline  ::capnp::Text::Reader getStr() const;

  inline bool getBool() const;

  inline bool hasJsonPath() const;
  inline  ::capnp::Text::Reader getJsonPath() 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 MapdIn::Builder {
public:
  typedef MapdIn 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  ::cereal::MapdIn::MapdInputType getType();
  inline void setType( ::cereal::MapdIn::MapdInputType value);

  inline float getFloat();
  inline void setFloat(float value);

  inline bool hasStr();
  inline  ::capnp::Text::Builder getStr();
  inline void setStr( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initStr(unsigned int size);
  inline void adoptStr(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownStr();

  inline bool getBool();
  inline void setBool(bool value);

  inline bool hasJsonPath();
  inline  ::capnp::Text::Builder getJsonPath();
  inline void setJsonPath( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initJsonPath(unsigned int size);
  inline void adoptJsonPath(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownJsonPath();

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 MapdIn::Pipeline {
public:
  typedef MapdIn 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 MapdOut::Reader {
public:
  typedef MapdOut 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 hasWayName() const;
  inline  ::capnp::Text::Reader getWayName() const;

  inline bool hasWayRef() const;
  inline  ::capnp::Text::Reader getWayRef() const;

  inline bool hasRoadName() const;
  inline  ::capnp::Text::Reader getRoadName() const;

  inline float getSpeedLimit() const;

  inline float getNextSpeedLimit() const;

  inline float getNextSpeedLimitDistance() const;

  inline bool hasHazard() const;
  inline  ::capnp::Text::Reader getHazard() const;

  inline bool hasNextHazard() const;
  inline  ::capnp::Text::Reader getNextHazard() const;

  inline float getNextHazardDistance() const;

  inline float getAdvisorySpeed() const;

  inline float getNextAdvisorySpeed() const;

  inline float getNextAdvisorySpeedDistance() const;

  inline bool getOneWay() const;

  inline  ::uint8_t getLanes() const;

  inline bool getTileLoaded() const;

  inline float getSpeedLimitSuggestedSpeed() const;

  inline float getSuggestedSpeed() const;

  inline float getEstimatedRoadWidth() const;

  inline  ::cereal::MapdOut::RoadContext getRoadContext() const;

  inline float getDistanceFromWayCenter() const;

  inline float getVisionCurveSpeed() const;

  inline float getMapCurveSpeed() const;

  inline  ::cereal::MapdOut::WaySelectionType getWaySelectionType() const;

  inline bool getSpeedLimitAccepted() const;

  inline  ::cereal::MapdOut::HighwayClass getHighwayClass() const;

  inline  ::int64_t getWayId() const;

  inline bool hasConditionalSpeedLimit() const;
  inline  ::capnp::Text::Reader getConditionalSpeedLimit() const;

  inline  ::uint16_t getSampleVersion() const;

  inline  ::cereal::MapdOut::SampleStatus getRoadStatus() const;

  inline  ::cereal::MapdOut::GpsSource getGpsSource() const;

  inline  ::uint64_t getGpsMonoTime() const;

  inline  ::uint64_t getComputedMonoTime() const;

  inline  ::uint64_t getSourceGeneration() const;

  inline  ::uint64_t getProducerSession() 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 MapdOut::Builder {
public:
  typedef MapdOut 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 hasWayName();
  inline  ::capnp::Text::Builder getWayName();
  inline void setWayName( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initWayName(unsigned int size);
  inline void adoptWayName(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownWayName();

  inline bool hasWayRef();
  inline  ::capnp::Text::Builder getWayRef();
  inline void setWayRef( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initWayRef(unsigned int size);
  inline void adoptWayRef(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownWayRef();

  inline bool hasRoadName();
  inline  ::capnp::Text::Builder getRoadName();
  inline void setRoadName( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initRoadName(unsigned int size);
  inline void adoptRoadName(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownRoadName();

  inline float getSpeedLimit();
  inline void setSpeedLimit(float value);

  inline float getNextSpeedLimit();
  inline void setNextSpeedLimit(float value);

  inline float getNextSpeedLimitDistance();
  inline void setNextSpeedLimitDistance(float value);

  inline bool hasHazard();
  inline  ::capnp::Text::Builder getHazard();
  inline void setHazard( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initHazard(unsigned int size);
  inline void adoptHazard(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownHazard();

  inline bool hasNextHazard();
  inline  ::capnp::Text::Builder getNextHazard();
  inline void setNextHazard( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initNextHazard(unsigned int size);
  inline void adoptNextHazard(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownNextHazard();

  inline float getNextHazardDistance();
  inline void setNextHazardDistance(float value);

  inline float getAdvisorySpeed();
  inline void setAdvisorySpeed(float value);

  inline float getNextAdvisorySpeed();
  inline void setNextAdvisorySpeed(float value);

  inline float getNextAdvisorySpeedDistance();
  inline void setNextAdvisorySpeedDistance(float value);

  inline bool getOneWay();
  inline void setOneWay(bool value);

  inline  ::uint8_t getLanes();
  inline void setLanes( ::uint8_t value);

  inline bool getTileLoaded();
  inline void setTileLoaded(bool value);

  inline float getSpeedLimitSuggestedSpeed();
  inline void setSpeedLimitSuggestedSpeed(float value);

  inline float getSuggestedSpeed();
  inline void setSuggestedSpeed(float value);

  inline float getEstimatedRoadWidth();
  inline void setEstimatedRoadWidth(float value);

  inline  ::cereal::MapdOut::RoadContext getRoadContext();
  inline void setRoadContext( ::cereal::MapdOut::RoadContext value);

  inline float getDistanceFromWayCenter();
  inline void setDistanceFromWayCenter(float value);

  inline float getVisionCurveSpeed();
  inline void setVisionCurveSpeed(float value);

  inline float getMapCurveSpeed();
  inline void setMapCurveSpeed(float value);

  inline  ::cereal::MapdOut::WaySelectionType getWaySelectionType();
  inline void setWaySelectionType( ::cereal::MapdOut::WaySelectionType value);

  inline bool getSpeedLimitAccepted();
  inline void setSpeedLimitAccepted(bool value);

  inline  ::cereal::MapdOut::HighwayClass getHighwayClass();
  inline void setHighwayClass( ::cereal::MapdOut::HighwayClass value);

  inline  ::int64_t getWayId();
  inline void setWayId( ::int64_t value);

  inline bool hasConditionalSpeedLimit();
  inline  ::capnp::Text::Builder getConditionalSpeedLimit();
  inline void setConditionalSpeedLimit( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initConditionalSpeedLimit(unsigned int size);
  inline void adoptConditionalSpeedLimit(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownConditionalSpeedLimit();

  inline  ::uint16_t getSampleVersion();
  inline void setSampleVersion( ::uint16_t value);

  inline  ::cereal::MapdOut::SampleStatus getRoadStatus();
  inline void setRoadStatus( ::cereal::MapdOut::SampleStatus value);

  inline  ::cereal::MapdOut::GpsSource getGpsSource();
  inline void setGpsSource( ::cereal::MapdOut::GpsSource value);

  inline  ::uint64_t getGpsMonoTime();
  inline void setGpsMonoTime( ::uint64_t value);

  inline  ::uint64_t getComputedMonoTime();
  inline void setComputedMonoTime( ::uint64_t value);

  inline  ::uint64_t getSourceGeneration();
  inline void setSourceGeneration( ::uint64_t value);

  inline  ::uint64_t getProducerSession();
  inline void setProducerSession( ::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 MapdOut::Pipeline {
public:
  typedef MapdOut 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 LearningControlEvidence::Reader {
public:
  typedef LearningControlEvidence 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  ::uint16_t getVersion() const;

  inline bool hasIdentity() const;
  inline  ::capnp::Text::Reader getIdentity() const;

  inline  ::uint64_t getGeneration() const;

  inline  ::uint64_t getControlMonoTime() const;

  inline  ::uint64_t getSourceStateMonoTime() const;

  inline bool hasDomain() const;
  inline  ::capnp::Text::Reader getDomain() const;

  inline bool hasStageRevision() const;
  inline  ::capnp::Text::Reader getStageRevision() const;

  inline bool hasResponseRevision() const;
  inline  ::capnp::Text::Reader getResponseRevision() const;

  inline double getRequested() const;

  inline bool hasFeatures() const;
  inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Reader getFeatures() const;

  inline double getBaselinePrediction() const;

  inline bool getEnabled() const;

  inline bool getManual() const;

  inline bool getActive() const;

  inline bool getValid() const;

  inline bool getOverride() const;

  inline bool getFault() const;

  inline bool getSaturated() const;

  inline bool getLimited() const;

  inline bool getModelWobble() const;

  inline bool getControllerChatter() const;

  inline bool hasStageSchemaRevision() const;
  inline  ::capnp::Text::Reader getStageSchemaRevision() const;

  inline bool hasStageValues() const;
  inline  ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>::Reader getStageValues() const;

  inline bool hasAppliedCoordinates() const;
  inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Reader getAppliedCoordinates() const;

  inline bool hasSourceEpoch() const;
  inline  ::capnp::Text::Reader getSourceEpoch() const;

  inline  ::uint64_t getSourceReceiptMonoTime() const;

  inline bool hasControllerMode() const;
  inline  ::capnp::Text::Reader getControllerMode() const;

  inline bool hasPolicy() const;
  inline  ::capnp::Text::Reader getPolicy() const;

  inline bool hasBaselineRevision() const;
  inline  ::capnp::Text::Reader getBaselineRevision() const;

  inline bool hasBaselineValues() const;
  inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Reader getBaselineValues() const;

  inline bool hasControllerRevision() const;
  inline  ::capnp::Text::Reader getControllerRevision() const;

  inline bool hasReplaySnapshot() const;
  inline  ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>::Reader getReplaySnapshot() const;

  inline bool hasReplayInputs() const;
  inline  ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>::Reader getReplayInputs() const;

  inline  ::uint64_t getSnapshotSequence() const;

  inline bool getTurnAssist() const;

  inline bool hasAppliedParameterNames() const;
  inline  ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>::Reader getAppliedParameterNames() const;

  inline bool getNativeRequired() const;

  inline  ::uint64_t getNativeObservedMonoTime() const;

  inline  ::uint64_t getNativeValidUntilMonoTime() const;

  inline bool getNativeAllowed() const;

  inline bool hasNativeIdentity() const;
  inline  ::capnp::Text::Reader getNativeIdentity() const;

  inline  ::uint64_t getAppliedProfileSequence() const;

  inline  ::uint64_t getAppliedProfileObservedMonoTime() const;

  inline  ::uint64_t getAppliedProfileValidUntilMonoTime() const;

  inline bool hasEffectTrace() const;
  inline  ::cereal::LearningControlEvidence::FullEffectTrace::Reader getEffectTrace() const;

  inline  ::uint64_t getEffectPrepareMonoTime() const;

  inline bool hasVehicleModelAnchor() const;
  inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Reader getVehicleModelAnchor() const;

  inline bool hasLiveAppliedCoordinates() const;
  inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Reader getLiveAppliedCoordinates() 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 LearningControlEvidence::Builder {
public:
  typedef LearningControlEvidence 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  ::uint16_t getVersion();
  inline void setVersion( ::uint16_t value);

  inline bool hasIdentity();
  inline  ::capnp::Text::Builder getIdentity();
  inline void setIdentity( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initIdentity(unsigned int size);
  inline void adoptIdentity(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownIdentity();

  inline  ::uint64_t getGeneration();
  inline void setGeneration( ::uint64_t value);

  inline  ::uint64_t getControlMonoTime();
  inline void setControlMonoTime( ::uint64_t value);

  inline  ::uint64_t getSourceStateMonoTime();
  inline void setSourceStateMonoTime( ::uint64_t value);

  inline bool hasDomain();
  inline  ::capnp::Text::Builder getDomain();
  inline void setDomain( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initDomain(unsigned int size);
  inline void adoptDomain(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownDomain();

  inline bool hasStageRevision();
  inline  ::capnp::Text::Builder getStageRevision();
  inline void setStageRevision( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initStageRevision(unsigned int size);
  inline void adoptStageRevision(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownStageRevision();

  inline bool hasResponseRevision();
  inline  ::capnp::Text::Builder getResponseRevision();
  inline void setResponseRevision( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initResponseRevision(unsigned int size);
  inline void adoptResponseRevision(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownResponseRevision();

  inline double getRequested();
  inline void setRequested(double value);

  inline bool hasFeatures();
  inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Builder getFeatures();
  inline void setFeatures( ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Reader value);
  inline void setFeatures(::kj::ArrayPtr<const double> value);
  inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Builder initFeatures(unsigned int size);
  inline void adoptFeatures(::capnp::Orphan< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>&& value);
  inline ::capnp::Orphan< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>> disownFeatures();

  inline double getBaselinePrediction();
  inline void setBaselinePrediction(double value);

  inline bool getEnabled();
  inline void setEnabled(bool value);

  inline bool getManual();
  inline void setManual(bool value);

  inline bool getActive();
  inline void setActive(bool value);

  inline bool getValid();
  inline void setValid(bool value);

  inline bool getOverride();
  inline void setOverride(bool value);

  inline bool getFault();
  inline void setFault(bool value);

  inline bool getSaturated();
  inline void setSaturated(bool value);

  inline bool getLimited();
  inline void setLimited(bool value);

  inline bool getModelWobble();
  inline void setModelWobble(bool value);

  inline bool getControllerChatter();
  inline void setControllerChatter(bool value);

  inline bool hasStageSchemaRevision();
  inline  ::capnp::Text::Builder getStageSchemaRevision();
  inline void setStageSchemaRevision( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initStageSchemaRevision(unsigned int size);
  inline void adoptStageSchemaRevision(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownStageSchemaRevision();

  inline bool hasStageValues();
  inline  ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>::Builder getStageValues();
  inline void setStageValues( ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>::Reader value);
  inline  ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>::Builder initStageValues(unsigned int size);
  inline void adoptStageValues(::capnp::Orphan< ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>>&& value);
  inline ::capnp::Orphan< ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>> disownStageValues();

  inline bool hasAppliedCoordinates();
  inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Builder getAppliedCoordinates();
  inline void setAppliedCoordinates( ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Reader value);
  inline void setAppliedCoordinates(::kj::ArrayPtr<const double> value);
  inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Builder initAppliedCoordinates(unsigned int size);
  inline void adoptAppliedCoordinates(::capnp::Orphan< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>&& value);
  inline ::capnp::Orphan< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>> disownAppliedCoordinates();

  inline bool hasSourceEpoch();
  inline  ::capnp::Text::Builder getSourceEpoch();
  inline void setSourceEpoch( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initSourceEpoch(unsigned int size);
  inline void adoptSourceEpoch(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownSourceEpoch();

  inline  ::uint64_t getSourceReceiptMonoTime();
  inline void setSourceReceiptMonoTime( ::uint64_t value);

  inline bool hasControllerMode();
  inline  ::capnp::Text::Builder getControllerMode();
  inline void setControllerMode( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initControllerMode(unsigned int size);
  inline void adoptControllerMode(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownControllerMode();

  inline bool hasPolicy();
  inline  ::capnp::Text::Builder getPolicy();
  inline void setPolicy( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initPolicy(unsigned int size);
  inline void adoptPolicy(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownPolicy();

  inline bool hasBaselineRevision();
  inline  ::capnp::Text::Builder getBaselineRevision();
  inline void setBaselineRevision( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initBaselineRevision(unsigned int size);
  inline void adoptBaselineRevision(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownBaselineRevision();

  inline bool hasBaselineValues();
  inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Builder getBaselineValues();
  inline void setBaselineValues( ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Reader value);
  inline void setBaselineValues(::kj::ArrayPtr<const double> value);
  inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Builder initBaselineValues(unsigned int size);
  inline void adoptBaselineValues(::capnp::Orphan< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>&& value);
  inline ::capnp::Orphan< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>> disownBaselineValues();

  inline bool hasControllerRevision();
  inline  ::capnp::Text::Builder getControllerRevision();
  inline void setControllerRevision( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initControllerRevision(unsigned int size);
  inline void adoptControllerRevision(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownControllerRevision();

  inline bool hasReplaySnapshot();
  inline  ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>::Builder getReplaySnapshot();
  inline void setReplaySnapshot( ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>::Reader value);
  inline  ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>::Builder initReplaySnapshot(unsigned int size);
  inline void adoptReplaySnapshot(::capnp::Orphan< ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>>&& value);
  inline ::capnp::Orphan< ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>> disownReplaySnapshot();

  inline bool hasReplayInputs();
  inline  ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>::Builder getReplayInputs();
  inline void setReplayInputs( ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>::Reader value);
  inline  ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>::Builder initReplayInputs(unsigned int size);
  inline void adoptReplayInputs(::capnp::Orphan< ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>>&& value);
  inline ::capnp::Orphan< ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>> disownReplayInputs();

  inline  ::uint64_t getSnapshotSequence();
  inline void setSnapshotSequence( ::uint64_t value);

  inline bool getTurnAssist();
  inline void setTurnAssist(bool value);

  inline bool hasAppliedParameterNames();
  inline  ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>::Builder getAppliedParameterNames();
  inline void setAppliedParameterNames( ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>::Reader value);
  inline void setAppliedParameterNames(::kj::ArrayPtr<const  ::capnp::Text::Reader> value);
  inline  ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>::Builder initAppliedParameterNames(unsigned int size);
  inline void adoptAppliedParameterNames(::capnp::Orphan< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>&& value);
  inline ::capnp::Orphan< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>> disownAppliedParameterNames();

  inline bool getNativeRequired();
  inline void setNativeRequired(bool value);

  inline  ::uint64_t getNativeObservedMonoTime();
  inline void setNativeObservedMonoTime( ::uint64_t value);

  inline  ::uint64_t getNativeValidUntilMonoTime();
  inline void setNativeValidUntilMonoTime( ::uint64_t value);

  inline bool getNativeAllowed();
  inline void setNativeAllowed(bool value);

  inline bool hasNativeIdentity();
  inline  ::capnp::Text::Builder getNativeIdentity();
  inline void setNativeIdentity( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initNativeIdentity(unsigned int size);
  inline void adoptNativeIdentity(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownNativeIdentity();

  inline  ::uint64_t getAppliedProfileSequence();
  inline void setAppliedProfileSequence( ::uint64_t value);

  inline  ::uint64_t getAppliedProfileObservedMonoTime();
  inline void setAppliedProfileObservedMonoTime( ::uint64_t value);

  inline  ::uint64_t getAppliedProfileValidUntilMonoTime();
  inline void setAppliedProfileValidUntilMonoTime( ::uint64_t value);

  inline bool hasEffectTrace();
  inline  ::cereal::LearningControlEvidence::FullEffectTrace::Builder getEffectTrace();
  inline void setEffectTrace( ::cereal::LearningControlEvidence::FullEffectTrace::Reader value);
  inline  ::cereal::LearningControlEvidence::FullEffectTrace::Builder initEffectTrace();
  inline void adoptEffectTrace(::capnp::Orphan< ::cereal::LearningControlEvidence::FullEffectTrace>&& value);
  inline ::capnp::Orphan< ::cereal::LearningControlEvidence::FullEffectTrace> disownEffectTrace();

  inline  ::uint64_t getEffectPrepareMonoTime();
  inline void setEffectPrepareMonoTime( ::uint64_t value);

  inline bool hasVehicleModelAnchor();
  inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Builder getVehicleModelAnchor();
  inline void setVehicleModelAnchor( ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Reader value);
  inline void setVehicleModelAnchor(::kj::ArrayPtr<const double> value);
  inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Builder initVehicleModelAnchor(unsigned int size);
  inline void adoptVehicleModelAnchor(::capnp::Orphan< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>&& value);
  inline ::capnp::Orphan< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>> disownVehicleModelAnchor();

  inline bool hasLiveAppliedCoordinates();
  inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Builder getLiveAppliedCoordinates();
  inline void setLiveAppliedCoordinates( ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Reader value);
  inline void setLiveAppliedCoordinates(::kj::ArrayPtr<const double> value);
  inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Builder initLiveAppliedCoordinates(unsigned int size);
  inline void adoptLiveAppliedCoordinates(::capnp::Orphan< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>&& value);
  inline ::capnp::Orphan< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>> disownLiveAppliedCoordinates();

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 LearningControlEvidence::Pipeline {
public:
  typedef LearningControlEvidence Pipelines;

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

  inline  ::cereal::LearningControlEvidence::FullEffectTrace::Pipeline getEffectTrace();
private:
  ::capnp::AnyPointer::Pipeline _typeless;
  friend class ::capnp::PipelineHook;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
};
#endif  // !CAPNP_LITE

class LearningControlEvidence::FullEffectTrace::Reader {
public:
  typedef FullEffectTrace 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  ::uint16_t getVersion() const;

  inline bool hasEnvelope() const;
  inline  ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope::Reader getEnvelope() const;

  inline  ::uint64_t getControlMonoTime() const;

  inline  ::uint64_t getPreviousMonoTime() const;

  inline bool getQualified() const;

  inline bool hasBefore() const;
  inline  ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>::Reader getBefore() const;

  inline bool hasTarget() const;
  inline  ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>::Reader getTarget() const;

  inline bool hasApplied() const;
  inline  ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>::Reader getApplied() const;

  inline bool hasAppliedFullProfileSha256() const;
  inline  ::capnp::Text::Reader getAppliedFullProfileSha256() 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 LearningControlEvidence::FullEffectTrace::Builder {
public:
  typedef FullEffectTrace 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  ::uint16_t getVersion();
  inline void setVersion( ::uint16_t value);

  inline bool hasEnvelope();
  inline  ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder getEnvelope();
  inline void setEnvelope( ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope::Reader value);
  inline  ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder initEnvelope();
  inline void adoptEnvelope(::capnp::Orphan< ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope>&& value);
  inline ::capnp::Orphan< ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope> disownEnvelope();

  inline  ::uint64_t getControlMonoTime();
  inline void setControlMonoTime( ::uint64_t value);

  inline  ::uint64_t getPreviousMonoTime();
  inline void setPreviousMonoTime( ::uint64_t value);

  inline bool getQualified();
  inline void setQualified(bool value);

  inline bool hasBefore();
  inline  ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>::Builder getBefore();
  inline void setBefore( ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>::Reader value);
  inline  ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>::Builder initBefore(unsigned int size);
  inline void adoptBefore(::capnp::Orphan< ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>>&& value);
  inline ::capnp::Orphan< ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>> disownBefore();

  inline bool hasTarget();
  inline  ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>::Builder getTarget();
  inline void setTarget( ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>::Reader value);
  inline  ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>::Builder initTarget(unsigned int size);
  inline void adoptTarget(::capnp::Orphan< ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>>&& value);
  inline ::capnp::Orphan< ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>> disownTarget();

  inline bool hasApplied();
  inline  ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>::Builder getApplied();
  inline void setApplied( ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>::Reader value);
  inline  ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>::Builder initApplied(unsigned int size);
  inline void adoptApplied(::capnp::Orphan< ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>>&& value);
  inline ::capnp::Orphan< ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>> disownApplied();

  inline bool hasAppliedFullProfileSha256();
  inline  ::capnp::Text::Builder getAppliedFullProfileSha256();
  inline void setAppliedFullProfileSha256( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initAppliedFullProfileSha256(unsigned int size);
  inline void adoptAppliedFullProfileSha256(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownAppliedFullProfileSha256();

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 LearningControlEvidence::FullEffectTrace::Pipeline {
public:
  typedef FullEffectTrace Pipelines;

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

  inline  ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope::Pipeline getEnvelope();
private:
  ::capnp::AnyPointer::Pipeline _typeless;
  friend class ::capnp::PipelineHook;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
};
#endif  // !CAPNP_LITE

class LearningControlEvidence::NamedValue::Reader {
public:
  typedef NamedValue 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 Which which() const;
  inline bool hasName() const;
  inline  ::capnp::Text::Reader getName() const;

  inline bool isNumber() const;
  inline double getNumber() const;

  inline bool isText() const;
  inline bool hasText() const;
  inline  ::capnp::Text::Reader getText() const;

  inline bool isBoolean() const;
  inline bool getBoolean() 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 LearningControlEvidence::NamedValue::Builder {
public:
  typedef NamedValue 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 Which which();
  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 isNumber();
  inline double getNumber();
  inline void setNumber(double value);

  inline bool isText();
  inline bool hasText();
  inline  ::capnp::Text::Builder getText();
  inline void setText( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initText(unsigned int size);
  inline void adoptText(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownText();

  inline bool isBoolean();
  inline bool getBoolean();
  inline void setBoolean(bool 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 LearningControlEvidence::NamedValue::Pipeline {
public:
  typedef NamedValue 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 LearningControlEvidence::StageValue::Reader {
public:
  typedef StageValue 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 hasName() const;
  inline  ::capnp::Text::Reader getName() const;

  inline double getValue() 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 LearningControlEvidence::StageValue::Builder {
public:
  typedef StageValue 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 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 double getValue();
  inline void setValue(double 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 LearningControlEvidence::StageValue::Pipeline {
public:
  typedef StageValue 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 LearningAppliedEvidence::Reader {
public:
  typedef LearningAppliedEvidence 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  ::uint16_t getVersion() const;

  inline  ::uint64_t getControlMonoTime() const;

  inline  ::uint64_t getSourceStateMonoTime() const;

  inline  ::uint64_t getAppliedMonoTime() const;

  inline bool hasDomain() const;
  inline  ::capnp::Text::Reader getDomain() const;

  inline double getApplied() const;

  inline bool getValid() const;

  inline bool getActive() const;

  inline bool getOverride() const;

  inline bool getFault() const;

  inline bool getLimited() const;

  inline bool getNativeAllowed() const;

  inline bool hasProjection() const;
  inline  ::cereal::LearningTorqueProjection::Reader getProjection() const;

  inline  ::uint64_t getCarrierFrame() const;

  inline  ::uint64_t getCarrierObservedMonoTime() 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 LearningAppliedEvidence::Builder {
public:
  typedef LearningAppliedEvidence 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  ::uint16_t getVersion();
  inline void setVersion( ::uint16_t value);

  inline  ::uint64_t getControlMonoTime();
  inline void setControlMonoTime( ::uint64_t value);

  inline  ::uint64_t getSourceStateMonoTime();
  inline void setSourceStateMonoTime( ::uint64_t value);

  inline  ::uint64_t getAppliedMonoTime();
  inline void setAppliedMonoTime( ::uint64_t value);

  inline bool hasDomain();
  inline  ::capnp::Text::Builder getDomain();
  inline void setDomain( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initDomain(unsigned int size);
  inline void adoptDomain(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownDomain();

  inline double getApplied();
  inline void setApplied(double value);

  inline bool getValid();
  inline void setValid(bool value);

  inline bool getActive();
  inline void setActive(bool value);

  inline bool getOverride();
  inline void setOverride(bool value);

  inline bool getFault();
  inline void setFault(bool value);

  inline bool getLimited();
  inline void setLimited(bool value);

  inline bool getNativeAllowed();
  inline void setNativeAllowed(bool value);

  inline bool hasProjection();
  inline  ::cereal::LearningTorqueProjection::Builder getProjection();
  inline void setProjection( ::cereal::LearningTorqueProjection::Reader value);
  inline  ::cereal::LearningTorqueProjection::Builder initProjection();
  inline void adoptProjection(::capnp::Orphan< ::cereal::LearningTorqueProjection>&& value);
  inline ::capnp::Orphan< ::cereal::LearningTorqueProjection> disownProjection();

  inline  ::uint64_t getCarrierFrame();
  inline void setCarrierFrame( ::uint64_t value);

  inline  ::uint64_t getCarrierObservedMonoTime();
  inline void setCarrierObservedMonoTime( ::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 LearningAppliedEvidence::Pipeline {
public:
  typedef LearningAppliedEvidence Pipelines;

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

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

class AutomaticRuntimeProfile::Reader {
public:
  typedef AutomaticRuntimeProfile 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  ::uint16_t getVersion() const;

  inline bool hasIdentity() const;
  inline  ::capnp::Text::Reader getIdentity() const;

  inline  ::uint64_t getSequence() const;

  inline  ::uint64_t getObservedMonoTime() const;

  inline  ::uint64_t getValidUntilMonoTime() const;

  inline bool hasPolicy() const;
  inline  ::capnp::Text::Reader getPolicy() const;

  inline bool hasParameters() const;
  inline  ::capnp::List< ::cereal::AutomaticRuntimeProfile::Parameter,  ::capnp::Kind::STRUCT>::Reader getParameters() const;

  inline bool hasCoefficients() const;
  inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Reader getCoefficients() const;

  inline bool hasTrainIds() const;
  inline  ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>::Reader getTrainIds() const;

  inline bool hasHeldoutIds() const;
  inline  ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>::Reader getHeldoutIds() const;

  inline double getBaselineLoss() const;

  inline double getCandidateLoss() const;

  inline bool hasCohortImprovements() const;
  inline  ::capnp::List< ::cereal::AutomaticRuntimeProfile::CohortImprovement,  ::capnp::Kind::STRUCT>::Reader getCohortImprovements() const;

  inline bool hasReplay() const;
  inline  ::cereal::AutomaticRuntimeProfile::ReplayValidation::Reader getReplay() const;

  inline bool hasFullSurface() const;
  inline  ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope::Reader getFullSurface() 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 AutomaticRuntimeProfile::Builder {
public:
  typedef AutomaticRuntimeProfile 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  ::uint16_t getVersion();
  inline void setVersion( ::uint16_t value);

  inline bool hasIdentity();
  inline  ::capnp::Text::Builder getIdentity();
  inline void setIdentity( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initIdentity(unsigned int size);
  inline void adoptIdentity(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownIdentity();

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

  inline  ::uint64_t getObservedMonoTime();
  inline void setObservedMonoTime( ::uint64_t value);

  inline  ::uint64_t getValidUntilMonoTime();
  inline void setValidUntilMonoTime( ::uint64_t value);

  inline bool hasPolicy();
  inline  ::capnp::Text::Builder getPolicy();
  inline void setPolicy( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initPolicy(unsigned int size);
  inline void adoptPolicy(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownPolicy();

  inline bool hasParameters();
  inline  ::capnp::List< ::cereal::AutomaticRuntimeProfile::Parameter,  ::capnp::Kind::STRUCT>::Builder getParameters();
  inline void setParameters( ::capnp::List< ::cereal::AutomaticRuntimeProfile::Parameter,  ::capnp::Kind::STRUCT>::Reader value);
  inline  ::capnp::List< ::cereal::AutomaticRuntimeProfile::Parameter,  ::capnp::Kind::STRUCT>::Builder initParameters(unsigned int size);
  inline void adoptParameters(::capnp::Orphan< ::capnp::List< ::cereal::AutomaticRuntimeProfile::Parameter,  ::capnp::Kind::STRUCT>>&& value);
  inline ::capnp::Orphan< ::capnp::List< ::cereal::AutomaticRuntimeProfile::Parameter,  ::capnp::Kind::STRUCT>> disownParameters();

  inline bool hasCoefficients();
  inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Builder getCoefficients();
  inline void setCoefficients( ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Reader value);
  inline void setCoefficients(::kj::ArrayPtr<const double> value);
  inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Builder initCoefficients(unsigned int size);
  inline void adoptCoefficients(::capnp::Orphan< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>&& value);
  inline ::capnp::Orphan< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>> disownCoefficients();

  inline bool hasTrainIds();
  inline  ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>::Builder getTrainIds();
  inline void setTrainIds( ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>::Reader value);
  inline void setTrainIds(::kj::ArrayPtr<const  ::capnp::Text::Reader> value);
  inline  ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>::Builder initTrainIds(unsigned int size);
  inline void adoptTrainIds(::capnp::Orphan< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>&& value);
  inline ::capnp::Orphan< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>> disownTrainIds();

  inline bool hasHeldoutIds();
  inline  ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>::Builder getHeldoutIds();
  inline void setHeldoutIds( ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>::Reader value);
  inline void setHeldoutIds(::kj::ArrayPtr<const  ::capnp::Text::Reader> value);
  inline  ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>::Builder initHeldoutIds(unsigned int size);
  inline void adoptHeldoutIds(::capnp::Orphan< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>&& value);
  inline ::capnp::Orphan< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>> disownHeldoutIds();

  inline double getBaselineLoss();
  inline void setBaselineLoss(double value);

  inline double getCandidateLoss();
  inline void setCandidateLoss(double value);

  inline bool hasCohortImprovements();
  inline  ::capnp::List< ::cereal::AutomaticRuntimeProfile::CohortImprovement,  ::capnp::Kind::STRUCT>::Builder getCohortImprovements();
  inline void setCohortImprovements( ::capnp::List< ::cereal::AutomaticRuntimeProfile::CohortImprovement,  ::capnp::Kind::STRUCT>::Reader value);
  inline  ::capnp::List< ::cereal::AutomaticRuntimeProfile::CohortImprovement,  ::capnp::Kind::STRUCT>::Builder initCohortImprovements(unsigned int size);
  inline void adoptCohortImprovements(::capnp::Orphan< ::capnp::List< ::cereal::AutomaticRuntimeProfile::CohortImprovement,  ::capnp::Kind::STRUCT>>&& value);
  inline ::capnp::Orphan< ::capnp::List< ::cereal::AutomaticRuntimeProfile::CohortImprovement,  ::capnp::Kind::STRUCT>> disownCohortImprovements();

  inline bool hasReplay();
  inline  ::cereal::AutomaticRuntimeProfile::ReplayValidation::Builder getReplay();
  inline void setReplay( ::cereal::AutomaticRuntimeProfile::ReplayValidation::Reader value);
  inline  ::cereal::AutomaticRuntimeProfile::ReplayValidation::Builder initReplay();
  inline void adoptReplay(::capnp::Orphan< ::cereal::AutomaticRuntimeProfile::ReplayValidation>&& value);
  inline ::capnp::Orphan< ::cereal::AutomaticRuntimeProfile::ReplayValidation> disownReplay();

  inline bool hasFullSurface();
  inline  ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder getFullSurface();
  inline void setFullSurface( ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope::Reader value);
  inline  ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder initFullSurface();
  inline void adoptFullSurface(::capnp::Orphan< ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope>&& value);
  inline ::capnp::Orphan< ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope> disownFullSurface();

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 AutomaticRuntimeProfile::Pipeline {
public:
  typedef AutomaticRuntimeProfile Pipelines;

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

  inline  ::cereal::AutomaticRuntimeProfile::ReplayValidation::Pipeline getReplay();
  inline  ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope::Pipeline getFullSurface();
private:
  ::capnp::AnyPointer::Pipeline _typeless;
  friend class ::capnp::PipelineHook;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
};
#endif  // !CAPNP_LITE

class AutomaticRuntimeProfile::FullSurfaceEnvelope::Reader {
public:
  typedef FullSurfaceEnvelope 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  ::uint16_t getVersion() const;

  inline bool hasManifestSha256() const;
  inline  ::capnp::Text::Reader getManifestSha256() const;

  inline bool hasFullOriginalAnchor() const;
  inline  ::capnp::Text::Reader getFullOriginalAnchor() const;

  inline bool hasTrialAnchor() const;
  inline  ::capnp::Text::Reader getTrialAnchor() const;

  inline bool hasContextKey() const;
  inline  ::capnp::Text::Reader getContextKey() const;

  inline bool hasCpSha256() const;
  inline  ::capnp::Text::Reader getCpSha256() const;

  inline bool hasControllerRevision() const;
  inline  ::capnp::Text::Reader getControllerRevision() const;

  inline bool hasSourceEpoch() const;
  inline  ::capnp::Text::Reader getSourceEpoch() const;

  inline bool hasResetGeneration() const;
  inline  ::capnp::Text::Reader getResetGeneration() const;

  inline bool hasSelectedBaselineRevision() const;
  inline  ::capnp::Text::Reader getSelectedBaselineRevision() const;

  inline bool hasPriorFullProfileSha256() const;
  inline  ::capnp::Text::Reader getPriorFullProfileSha256() const;

  inline bool hasFullProfileSha256() const;
  inline  ::capnp::Text::Reader getFullProfileSha256() const;

  inline bool hasPriorCoordinates() const;
  inline  ::capnp::List< ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope::Coordinate,  ::capnp::Kind::STRUCT>::Reader getPriorCoordinates() const;

  inline bool hasCoordinates() const;
  inline  ::capnp::List< ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope::Coordinate,  ::capnp::Kind::STRUCT>::Reader getCoordinates() const;

  inline bool hasTrialNames() const;
  inline  ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>::Reader getTrialNames() const;

  inline bool hasPersistentSourceEpoch() const;
  inline  ::capnp::Text::Reader getPersistentSourceEpoch() const;

  inline bool hasOperation() const;
  inline  ::capnp::Text::Reader getOperation() const;

  inline bool hasHistoryFullProfileSha256() const;
  inline  ::capnp::Text::Reader getHistoryFullProfileSha256() const;

  inline bool hasRestoreTransactionSha256() const;
  inline  ::capnp::Text::Reader getRestoreTransactionSha256() 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 AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder {
public:
  typedef FullSurfaceEnvelope 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  ::uint16_t getVersion();
  inline void setVersion( ::uint16_t value);

  inline bool hasManifestSha256();
  inline  ::capnp::Text::Builder getManifestSha256();
  inline void setManifestSha256( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initManifestSha256(unsigned int size);
  inline void adoptManifestSha256(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownManifestSha256();

  inline bool hasFullOriginalAnchor();
  inline  ::capnp::Text::Builder getFullOriginalAnchor();
  inline void setFullOriginalAnchor( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initFullOriginalAnchor(unsigned int size);
  inline void adoptFullOriginalAnchor(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownFullOriginalAnchor();

  inline bool hasTrialAnchor();
  inline  ::capnp::Text::Builder getTrialAnchor();
  inline void setTrialAnchor( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initTrialAnchor(unsigned int size);
  inline void adoptTrialAnchor(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownTrialAnchor();

  inline bool hasContextKey();
  inline  ::capnp::Text::Builder getContextKey();
  inline void setContextKey( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initContextKey(unsigned int size);
  inline void adoptContextKey(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownContextKey();

  inline bool hasCpSha256();
  inline  ::capnp::Text::Builder getCpSha256();
  inline void setCpSha256( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initCpSha256(unsigned int size);
  inline void adoptCpSha256(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownCpSha256();

  inline bool hasControllerRevision();
  inline  ::capnp::Text::Builder getControllerRevision();
  inline void setControllerRevision( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initControllerRevision(unsigned int size);
  inline void adoptControllerRevision(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownControllerRevision();

  inline bool hasSourceEpoch();
  inline  ::capnp::Text::Builder getSourceEpoch();
  inline void setSourceEpoch( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initSourceEpoch(unsigned int size);
  inline void adoptSourceEpoch(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownSourceEpoch();

  inline bool hasResetGeneration();
  inline  ::capnp::Text::Builder getResetGeneration();
  inline void setResetGeneration( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initResetGeneration(unsigned int size);
  inline void adoptResetGeneration(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownResetGeneration();

  inline bool hasSelectedBaselineRevision();
  inline  ::capnp::Text::Builder getSelectedBaselineRevision();
  inline void setSelectedBaselineRevision( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initSelectedBaselineRevision(unsigned int size);
  inline void adoptSelectedBaselineRevision(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownSelectedBaselineRevision();

  inline bool hasPriorFullProfileSha256();
  inline  ::capnp::Text::Builder getPriorFullProfileSha256();
  inline void setPriorFullProfileSha256( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initPriorFullProfileSha256(unsigned int size);
  inline void adoptPriorFullProfileSha256(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownPriorFullProfileSha256();

  inline bool hasFullProfileSha256();
  inline  ::capnp::Text::Builder getFullProfileSha256();
  inline void setFullProfileSha256( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initFullProfileSha256(unsigned int size);
  inline void adoptFullProfileSha256(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownFullProfileSha256();

  inline bool hasPriorCoordinates();
  inline  ::capnp::List< ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope::Coordinate,  ::capnp::Kind::STRUCT>::Builder getPriorCoordinates();
  inline void setPriorCoordinates( ::capnp::List< ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope::Coordinate,  ::capnp::Kind::STRUCT>::Reader value);
  inline  ::capnp::List< ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope::Coordinate,  ::capnp::Kind::STRUCT>::Builder initPriorCoordinates(unsigned int size);
  inline void adoptPriorCoordinates(::capnp::Orphan< ::capnp::List< ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope::Coordinate,  ::capnp::Kind::STRUCT>>&& value);
  inline ::capnp::Orphan< ::capnp::List< ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope::Coordinate,  ::capnp::Kind::STRUCT>> disownPriorCoordinates();

  inline bool hasCoordinates();
  inline  ::capnp::List< ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope::Coordinate,  ::capnp::Kind::STRUCT>::Builder getCoordinates();
  inline void setCoordinates( ::capnp::List< ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope::Coordinate,  ::capnp::Kind::STRUCT>::Reader value);
  inline  ::capnp::List< ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope::Coordinate,  ::capnp::Kind::STRUCT>::Builder initCoordinates(unsigned int size);
  inline void adoptCoordinates(::capnp::Orphan< ::capnp::List< ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope::Coordinate,  ::capnp::Kind::STRUCT>>&& value);
  inline ::capnp::Orphan< ::capnp::List< ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope::Coordinate,  ::capnp::Kind::STRUCT>> disownCoordinates();

  inline bool hasTrialNames();
  inline  ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>::Builder getTrialNames();
  inline void setTrialNames( ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>::Reader value);
  inline void setTrialNames(::kj::ArrayPtr<const  ::capnp::Text::Reader> value);
  inline  ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>::Builder initTrialNames(unsigned int size);
  inline void adoptTrialNames(::capnp::Orphan< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>&& value);
  inline ::capnp::Orphan< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>> disownTrialNames();

  inline bool hasPersistentSourceEpoch();
  inline  ::capnp::Text::Builder getPersistentSourceEpoch();
  inline void setPersistentSourceEpoch( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initPersistentSourceEpoch(unsigned int size);
  inline void adoptPersistentSourceEpoch(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownPersistentSourceEpoch();

  inline bool hasOperation();
  inline  ::capnp::Text::Builder getOperation();
  inline void setOperation( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initOperation(unsigned int size);
  inline void adoptOperation(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownOperation();

  inline bool hasHistoryFullProfileSha256();
  inline  ::capnp::Text::Builder getHistoryFullProfileSha256();
  inline void setHistoryFullProfileSha256( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initHistoryFullProfileSha256(unsigned int size);
  inline void adoptHistoryFullProfileSha256(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownHistoryFullProfileSha256();

  inline bool hasRestoreTransactionSha256();
  inline  ::capnp::Text::Builder getRestoreTransactionSha256();
  inline void setRestoreTransactionSha256( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initRestoreTransactionSha256(unsigned int size);
  inline void adoptRestoreTransactionSha256(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownRestoreTransactionSha256();

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 AutomaticRuntimeProfile::FullSurfaceEnvelope::Pipeline {
public:
  typedef FullSurfaceEnvelope 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 AutomaticRuntimeProfile::FullSurfaceEnvelope::Coordinate::Reader {
public:
  typedef Coordinate 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 hasName() const;
  inline  ::capnp::Text::Reader getName() const;

  inline double getValue() 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 AutomaticRuntimeProfile::FullSurfaceEnvelope::Coordinate::Builder {
public:
  typedef Coordinate 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 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 double getValue();
  inline void setValue(double 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 AutomaticRuntimeProfile::FullSurfaceEnvelope::Coordinate::Pipeline {
public:
  typedef Coordinate 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 AutomaticRuntimeProfile::ReplayValidation::Reader {
public:
  typedef ReplayValidation 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 hasBaselineRevision() const;
  inline  ::capnp::Text::Reader getBaselineRevision() const;

  inline bool hasPhysicalModelRevision() const;
  inline  ::capnp::Text::Reader getPhysicalModelRevision() const;

  inline bool getNoSaturationRegression() const;

  inline bool getNoSlewRegression() const;

  inline double getWorstCohortImprovement() const;

  inline bool hasNativeBaselineValues() const;
  inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Reader getNativeBaselineValues() 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 AutomaticRuntimeProfile::ReplayValidation::Builder {
public:
  typedef ReplayValidation 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 hasBaselineRevision();
  inline  ::capnp::Text::Builder getBaselineRevision();
  inline void setBaselineRevision( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initBaselineRevision(unsigned int size);
  inline void adoptBaselineRevision(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownBaselineRevision();

  inline bool hasPhysicalModelRevision();
  inline  ::capnp::Text::Builder getPhysicalModelRevision();
  inline void setPhysicalModelRevision( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initPhysicalModelRevision(unsigned int size);
  inline void adoptPhysicalModelRevision(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownPhysicalModelRevision();

  inline bool getNoSaturationRegression();
  inline void setNoSaturationRegression(bool value);

  inline bool getNoSlewRegression();
  inline void setNoSlewRegression(bool value);

  inline double getWorstCohortImprovement();
  inline void setWorstCohortImprovement(double value);

  inline bool hasNativeBaselineValues();
  inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Builder getNativeBaselineValues();
  inline void setNativeBaselineValues( ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Reader value);
  inline void setNativeBaselineValues(::kj::ArrayPtr<const double> value);
  inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Builder initNativeBaselineValues(unsigned int size);
  inline void adoptNativeBaselineValues(::capnp::Orphan< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>&& value);
  inline ::capnp::Orphan< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>> disownNativeBaselineValues();

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 AutomaticRuntimeProfile::ReplayValidation::Pipeline {
public:
  typedef ReplayValidation 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 AutomaticRuntimeProfile::Parameter::Reader {
public:
  typedef Parameter 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 hasName() const;
  inline  ::capnp::Text::Reader getName() const;

  inline bool hasStageRevision() const;
  inline  ::capnp::Text::Reader getStageRevision() const;

  inline double getLow() const;

  inline double getHigh() const;

  inline double getMaxStep() const;

  inline double getSlewPerS() const;

  inline double getExcitationFloor() 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 AutomaticRuntimeProfile::Parameter::Builder {
public:
  typedef Parameter 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 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 hasStageRevision();
  inline  ::capnp::Text::Builder getStageRevision();
  inline void setStageRevision( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initStageRevision(unsigned int size);
  inline void adoptStageRevision(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownStageRevision();

  inline double getLow();
  inline void setLow(double value);

  inline double getHigh();
  inline void setHigh(double value);

  inline double getMaxStep();
  inline void setMaxStep(double value);

  inline double getSlewPerS();
  inline void setSlewPerS(double value);

  inline double getExcitationFloor();
  inline void setExcitationFloor(double 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 AutomaticRuntimeProfile::Parameter::Pipeline {
public:
  typedef Parameter 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 AutomaticRuntimeProfile::CohortImprovement::Reader {
public:
  typedef CohortImprovement 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 hasName() const;
  inline  ::capnp::Text::Reader getName() const;

  inline double getLowerBound() 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 AutomaticRuntimeProfile::CohortImprovement::Builder {
public:
  typedef CohortImprovement 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 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 double getLowerBound();
  inline void setLowerBound(double 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 AutomaticRuntimeProfile::CohortImprovement::Pipeline {
public:
  typedef CohortImprovement 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 AutomaticLearningSourceReceipt::Reader {
public:
  typedef AutomaticLearningSourceReceipt 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  ::uint16_t getVersion() const;

  inline bool getEnabled() const;

  inline bool getManual() const;

  inline bool hasResetGeneration() const;
  inline  ::capnp::Text::Reader getResetGeneration() const;

  inline bool hasSourceEpoch() const;
  inline  ::capnp::Text::Reader getSourceEpoch() const;

  inline  ::uint64_t getObservedMonoTime() const;

  inline  ::uint64_t getValidUntilMonoTime() const;

  inline bool hasCpSha256() const;
  inline  ::capnp::Text::Reader getCpSha256() const;

  inline bool hasCalibrationBasis() const;
  inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Reader getCalibrationBasis() const;

  inline bool hasCalibrationGeneration() const;
  inline  ::capnp::Text::Reader getCalibrationGeneration() const;

  inline bool hasPersistentSourceEpoch() const;
  inline  ::capnp::Text::Reader getPersistentSourceEpoch() 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 AutomaticLearningSourceReceipt::Builder {
public:
  typedef AutomaticLearningSourceReceipt 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  ::uint16_t getVersion();
  inline void setVersion( ::uint16_t value);

  inline bool getEnabled();
  inline void setEnabled(bool value);

  inline bool getManual();
  inline void setManual(bool value);

  inline bool hasResetGeneration();
  inline  ::capnp::Text::Builder getResetGeneration();
  inline void setResetGeneration( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initResetGeneration(unsigned int size);
  inline void adoptResetGeneration(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownResetGeneration();

  inline bool hasSourceEpoch();
  inline  ::capnp::Text::Builder getSourceEpoch();
  inline void setSourceEpoch( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initSourceEpoch(unsigned int size);
  inline void adoptSourceEpoch(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownSourceEpoch();

  inline  ::uint64_t getObservedMonoTime();
  inline void setObservedMonoTime( ::uint64_t value);

  inline  ::uint64_t getValidUntilMonoTime();
  inline void setValidUntilMonoTime( ::uint64_t value);

  inline bool hasCpSha256();
  inline  ::capnp::Text::Builder getCpSha256();
  inline void setCpSha256( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initCpSha256(unsigned int size);
  inline void adoptCpSha256(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownCpSha256();

  inline bool hasCalibrationBasis();
  inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Builder getCalibrationBasis();
  inline void setCalibrationBasis( ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Reader value);
  inline void setCalibrationBasis(::kj::ArrayPtr<const double> value);
  inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Builder initCalibrationBasis(unsigned int size);
  inline void adoptCalibrationBasis(::capnp::Orphan< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>&& value);
  inline ::capnp::Orphan< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>> disownCalibrationBasis();

  inline bool hasCalibrationGeneration();
  inline  ::capnp::Text::Builder getCalibrationGeneration();
  inline void setCalibrationGeneration( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initCalibrationGeneration(unsigned int size);
  inline void adoptCalibrationGeneration(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownCalibrationGeneration();

  inline bool hasPersistentSourceEpoch();
  inline  ::capnp::Text::Builder getPersistentSourceEpoch();
  inline void setPersistentSourceEpoch( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initPersistentSourceEpoch(unsigned int size);
  inline void adoptPersistentSourceEpoch(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownPersistentSourceEpoch();

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 AutomaticLearningSourceReceipt::Pipeline {
public:
  typedef AutomaticLearningSourceReceipt 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 LearningApplication::Reader {
public:
  typedef LearningApplication 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  ::uint16_t getVersion() const;

  inline bool hasIdentity() const;
  inline  ::capnp::Text::Reader getIdentity() const;

  inline  ::uint64_t getProfileSequence() const;

  inline  ::uint64_t getObservedMonoTime() const;

  inline bool hasStatus() const;
  inline  ::capnp::Text::Reader getStatus() const;

  inline bool hasActualCoordinates() const;
  inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Reader getActualCoordinates() const;

  inline bool hasReason() const;
  inline  ::capnp::Text::Reader getReason() const;

  inline bool hasBaselineRevision() const;
  inline  ::capnp::Text::Reader getBaselineRevision() const;

  inline bool hasPhysicalModelRevision() const;
  inline  ::capnp::Text::Reader getPhysicalModelRevision() const;

  inline bool hasEffectManifestSha256() const;
  inline  ::capnp::Text::Reader getEffectManifestSha256() const;

  inline bool hasEffectOriginalAnchor() const;
  inline  ::capnp::Text::Reader getEffectOriginalAnchor() const;

  inline bool hasEffectAppliedProfileSha256() const;
  inline  ::capnp::Text::Reader getEffectAppliedProfileSha256() 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 LearningApplication::Builder {
public:
  typedef LearningApplication 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  ::uint16_t getVersion();
  inline void setVersion( ::uint16_t value);

  inline bool hasIdentity();
  inline  ::capnp::Text::Builder getIdentity();
  inline void setIdentity( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initIdentity(unsigned int size);
  inline void adoptIdentity(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownIdentity();

  inline  ::uint64_t getProfileSequence();
  inline void setProfileSequence( ::uint64_t value);

  inline  ::uint64_t getObservedMonoTime();
  inline void setObservedMonoTime( ::uint64_t value);

  inline bool hasStatus();
  inline  ::capnp::Text::Builder getStatus();
  inline void setStatus( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initStatus(unsigned int size);
  inline void adoptStatus(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownStatus();

  inline bool hasActualCoordinates();
  inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Builder getActualCoordinates();
  inline void setActualCoordinates( ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Reader value);
  inline void setActualCoordinates(::kj::ArrayPtr<const double> value);
  inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Builder initActualCoordinates(unsigned int size);
  inline void adoptActualCoordinates(::capnp::Orphan< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>&& value);
  inline ::capnp::Orphan< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>> disownActualCoordinates();

  inline bool hasReason();
  inline  ::capnp::Text::Builder getReason();
  inline void setReason( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initReason(unsigned int size);
  inline void adoptReason(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownReason();

  inline bool hasBaselineRevision();
  inline  ::capnp::Text::Builder getBaselineRevision();
  inline void setBaselineRevision( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initBaselineRevision(unsigned int size);
  inline void adoptBaselineRevision(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownBaselineRevision();

  inline bool hasPhysicalModelRevision();
  inline  ::capnp::Text::Builder getPhysicalModelRevision();
  inline void setPhysicalModelRevision( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initPhysicalModelRevision(unsigned int size);
  inline void adoptPhysicalModelRevision(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownPhysicalModelRevision();

  inline bool hasEffectManifestSha256();
  inline  ::capnp::Text::Builder getEffectManifestSha256();
  inline void setEffectManifestSha256( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initEffectManifestSha256(unsigned int size);
  inline void adoptEffectManifestSha256(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownEffectManifestSha256();

  inline bool hasEffectOriginalAnchor();
  inline  ::capnp::Text::Builder getEffectOriginalAnchor();
  inline void setEffectOriginalAnchor( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initEffectOriginalAnchor(unsigned int size);
  inline void adoptEffectOriginalAnchor(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownEffectOriginalAnchor();

  inline bool hasEffectAppliedProfileSha256();
  inline  ::capnp::Text::Builder getEffectAppliedProfileSha256();
  inline void setEffectAppliedProfileSha256( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initEffectAppliedProfileSha256(unsigned int size);
  inline void adoptEffectAppliedProfileSha256(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownEffectAppliedProfileSha256();

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 LearningApplication::Pipeline {
public:
  typedef LearningApplication 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 FordLearningEvidence::Reader {
public:
  typedef FordLearningEvidence 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  ::uint16_t getVersion() const;

  inline bool hasIdentity() const;
  inline  ::capnp::Text::Reader getIdentity() const;

  inline  ::uint64_t getGeneration() const;

  inline bool hasSourceEpoch() const;
  inline  ::capnp::Text::Reader getSourceEpoch() const;

  inline bool hasBaselineRevision() const;
  inline  ::capnp::Text::Reader getBaselineRevision() const;

  inline bool hasBaselineValues() const;
  inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Reader getBaselineValues() const;

  inline bool hasControllerRevision() const;
  inline  ::capnp::Text::Reader getControllerRevision() const;

  inline bool hasCpSha256() const;
  inline  ::capnp::Text::Reader getCpSha256() const;

  inline bool hasControllerMode() const;
  inline  ::capnp::Text::Reader getControllerMode() const;

  inline bool hasPolicy() const;
  inline  ::capnp::Text::Reader getPolicy() const;

  inline bool hasConversionRevision() const;
  inline  ::capnp::Text::Reader getConversionRevision() const;

  inline bool hasStageRevision() const;
  inline  ::capnp::Text::Reader getStageRevision() const;

  inline  ::uint64_t getSourceReceiptMonoTime() const;

  inline  ::uint64_t getSourceValidUntilMonoTime() const;

  inline bool getEnabled() const;

  inline bool getManual() const;

  inline bool hasRows() const;
  inline  ::capnp::List< ::cereal::FordLearningEvent,  ::capnp::Kind::STRUCT>::Reader getRows() const;

  inline  ::uint64_t getDropped() const;

  inline  ::uint64_t getAppliedProfileSequence() const;

  inline  ::uint64_t getAppliedProfileObservedMonoTime() const;

  inline  ::uint64_t getAppliedProfileValidUntilMonoTime() 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 FordLearningEvidence::Builder {
public:
  typedef FordLearningEvidence 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  ::uint16_t getVersion();
  inline void setVersion( ::uint16_t value);

  inline bool hasIdentity();
  inline  ::capnp::Text::Builder getIdentity();
  inline void setIdentity( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initIdentity(unsigned int size);
  inline void adoptIdentity(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownIdentity();

  inline  ::uint64_t getGeneration();
  inline void setGeneration( ::uint64_t value);

  inline bool hasSourceEpoch();
  inline  ::capnp::Text::Builder getSourceEpoch();
  inline void setSourceEpoch( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initSourceEpoch(unsigned int size);
  inline void adoptSourceEpoch(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownSourceEpoch();

  inline bool hasBaselineRevision();
  inline  ::capnp::Text::Builder getBaselineRevision();
  inline void setBaselineRevision( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initBaselineRevision(unsigned int size);
  inline void adoptBaselineRevision(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownBaselineRevision();

  inline bool hasBaselineValues();
  inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Builder getBaselineValues();
  inline void setBaselineValues( ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Reader value);
  inline void setBaselineValues(::kj::ArrayPtr<const double> value);
  inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Builder initBaselineValues(unsigned int size);
  inline void adoptBaselineValues(::capnp::Orphan< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>&& value);
  inline ::capnp::Orphan< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>> disownBaselineValues();

  inline bool hasControllerRevision();
  inline  ::capnp::Text::Builder getControllerRevision();
  inline void setControllerRevision( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initControllerRevision(unsigned int size);
  inline void adoptControllerRevision(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownControllerRevision();

  inline bool hasCpSha256();
  inline  ::capnp::Text::Builder getCpSha256();
  inline void setCpSha256( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initCpSha256(unsigned int size);
  inline void adoptCpSha256(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownCpSha256();

  inline bool hasControllerMode();
  inline  ::capnp::Text::Builder getControllerMode();
  inline void setControllerMode( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initControllerMode(unsigned int size);
  inline void adoptControllerMode(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownControllerMode();

  inline bool hasPolicy();
  inline  ::capnp::Text::Builder getPolicy();
  inline void setPolicy( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initPolicy(unsigned int size);
  inline void adoptPolicy(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownPolicy();

  inline bool hasConversionRevision();
  inline  ::capnp::Text::Builder getConversionRevision();
  inline void setConversionRevision( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initConversionRevision(unsigned int size);
  inline void adoptConversionRevision(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownConversionRevision();

  inline bool hasStageRevision();
  inline  ::capnp::Text::Builder getStageRevision();
  inline void setStageRevision( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initStageRevision(unsigned int size);
  inline void adoptStageRevision(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownStageRevision();

  inline  ::uint64_t getSourceReceiptMonoTime();
  inline void setSourceReceiptMonoTime( ::uint64_t value);

  inline  ::uint64_t getSourceValidUntilMonoTime();
  inline void setSourceValidUntilMonoTime( ::uint64_t value);

  inline bool getEnabled();
  inline void setEnabled(bool value);

  inline bool getManual();
  inline void setManual(bool value);

  inline bool hasRows();
  inline  ::capnp::List< ::cereal::FordLearningEvent,  ::capnp::Kind::STRUCT>::Builder getRows();
  inline void setRows( ::capnp::List< ::cereal::FordLearningEvent,  ::capnp::Kind::STRUCT>::Reader value);
  inline  ::capnp::List< ::cereal::FordLearningEvent,  ::capnp::Kind::STRUCT>::Builder initRows(unsigned int size);
  inline void adoptRows(::capnp::Orphan< ::capnp::List< ::cereal::FordLearningEvent,  ::capnp::Kind::STRUCT>>&& value);
  inline ::capnp::Orphan< ::capnp::List< ::cereal::FordLearningEvent,  ::capnp::Kind::STRUCT>> disownRows();

  inline  ::uint64_t getDropped();
  inline void setDropped( ::uint64_t value);

  inline  ::uint64_t getAppliedProfileSequence();
  inline void setAppliedProfileSequence( ::uint64_t value);

  inline  ::uint64_t getAppliedProfileObservedMonoTime();
  inline void setAppliedProfileObservedMonoTime( ::uint64_t value);

  inline  ::uint64_t getAppliedProfileValidUntilMonoTime();
  inline void setAppliedProfileValidUntilMonoTime( ::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 FordLearningEvidence::Pipeline {
public:
  typedef FordLearningEvidence 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 FordLearningEvent::Reader {
public:
  typedef FordLearningEvent 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  ::uint64_t getEventMonoTime() const;

  inline  ::uint64_t getSequence() const;

  inline bool hasKind() const;
  inline  ::capnp::Text::Reader getKind() const;

  inline bool hasInputs() const;
  inline  ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>::Reader getInputs() const;

  inline double getAppliedCoefficient() const;

  inline bool hasActualPending() const;
  inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Reader getActualPending() const;

  inline bool hasActualCommand() const;
  inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Reader getActualCommand() const;

  inline  ::uint64_t getControlMonoTime() const;

  inline  ::uint64_t getPendingControlMonoTime() const;

  inline  ::uint64_t getAnnouncedControlMonoTime() const;

  inline  ::uint64_t getCarStateMonoTime() const;

  inline bool getNativeAllowed() const;

  inline bool getFault() const;

  inline bool getOverride() const;

  inline bool getLimited() const;

  inline bool getHasWirePath() const;

  inline double getActualWirePath() const;

  inline bool hasCheckpoint() const;
  inline  ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>::Reader getCheckpoint() const;

  inline  ::uint64_t getCheckpointSequence() const;

  inline  ::uint64_t getSourceReceiptMonoTime() const;

  inline  ::uint64_t getSourceValidUntilMonoTime() const;

  inline  ::uint64_t getAppliedProfileSequence() const;

  inline  ::uint64_t getAppliedProfileObservedMonoTime() const;

  inline  ::uint64_t getAppliedProfileValidUntilMonoTime() const;

  inline bool hasNativeIdentity() const;
  inline  ::capnp::Text::Reader getNativeIdentity() const;

  inline  ::uint64_t getNativeObservedMonoTime() const;

  inline  ::uint64_t getNativeValidUntilMonoTime() const;

  inline  ::uint64_t getNativeValidatedMonoTime() const;

  inline  ::uint64_t getNativeCommandMonoTime() const;

  inline double getAnnouncedCoefficient() 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 FordLearningEvent::Builder {
public:
  typedef FordLearningEvent 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  ::uint64_t getEventMonoTime();
  inline void setEventMonoTime( ::uint64_t value);

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

  inline bool hasKind();
  inline  ::capnp::Text::Builder getKind();
  inline void setKind( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initKind(unsigned int size);
  inline void adoptKind(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownKind();

  inline bool hasInputs();
  inline  ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>::Builder getInputs();
  inline void setInputs( ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>::Reader value);
  inline  ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>::Builder initInputs(unsigned int size);
  inline void adoptInputs(::capnp::Orphan< ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>>&& value);
  inline ::capnp::Orphan< ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>> disownInputs();

  inline double getAppliedCoefficient();
  inline void setAppliedCoefficient(double value);

  inline bool hasActualPending();
  inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Builder getActualPending();
  inline void setActualPending( ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Reader value);
  inline void setActualPending(::kj::ArrayPtr<const double> value);
  inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Builder initActualPending(unsigned int size);
  inline void adoptActualPending(::capnp::Orphan< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>&& value);
  inline ::capnp::Orphan< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>> disownActualPending();

  inline bool hasActualCommand();
  inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Builder getActualCommand();
  inline void setActualCommand( ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Reader value);
  inline void setActualCommand(::kj::ArrayPtr<const double> value);
  inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Builder initActualCommand(unsigned int size);
  inline void adoptActualCommand(::capnp::Orphan< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>&& value);
  inline ::capnp::Orphan< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>> disownActualCommand();

  inline  ::uint64_t getControlMonoTime();
  inline void setControlMonoTime( ::uint64_t value);

  inline  ::uint64_t getPendingControlMonoTime();
  inline void setPendingControlMonoTime( ::uint64_t value);

  inline  ::uint64_t getAnnouncedControlMonoTime();
  inline void setAnnouncedControlMonoTime( ::uint64_t value);

  inline  ::uint64_t getCarStateMonoTime();
  inline void setCarStateMonoTime( ::uint64_t value);

  inline bool getNativeAllowed();
  inline void setNativeAllowed(bool value);

  inline bool getFault();
  inline void setFault(bool value);

  inline bool getOverride();
  inline void setOverride(bool value);

  inline bool getLimited();
  inline void setLimited(bool value);

  inline bool getHasWirePath();
  inline void setHasWirePath(bool value);

  inline double getActualWirePath();
  inline void setActualWirePath(double value);

  inline bool hasCheckpoint();
  inline  ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>::Builder getCheckpoint();
  inline void setCheckpoint( ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>::Reader value);
  inline  ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>::Builder initCheckpoint(unsigned int size);
  inline void adoptCheckpoint(::capnp::Orphan< ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>>&& value);
  inline ::capnp::Orphan< ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>> disownCheckpoint();

  inline  ::uint64_t getCheckpointSequence();
  inline void setCheckpointSequence( ::uint64_t value);

  inline  ::uint64_t getSourceReceiptMonoTime();
  inline void setSourceReceiptMonoTime( ::uint64_t value);

  inline  ::uint64_t getSourceValidUntilMonoTime();
  inline void setSourceValidUntilMonoTime( ::uint64_t value);

  inline  ::uint64_t getAppliedProfileSequence();
  inline void setAppliedProfileSequence( ::uint64_t value);

  inline  ::uint64_t getAppliedProfileObservedMonoTime();
  inline void setAppliedProfileObservedMonoTime( ::uint64_t value);

  inline  ::uint64_t getAppliedProfileValidUntilMonoTime();
  inline void setAppliedProfileValidUntilMonoTime( ::uint64_t value);

  inline bool hasNativeIdentity();
  inline  ::capnp::Text::Builder getNativeIdentity();
  inline void setNativeIdentity( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initNativeIdentity(unsigned int size);
  inline void adoptNativeIdentity(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownNativeIdentity();

  inline  ::uint64_t getNativeObservedMonoTime();
  inline void setNativeObservedMonoTime( ::uint64_t value);

  inline  ::uint64_t getNativeValidUntilMonoTime();
  inline void setNativeValidUntilMonoTime( ::uint64_t value);

  inline  ::uint64_t getNativeValidatedMonoTime();
  inline void setNativeValidatedMonoTime( ::uint64_t value);

  inline  ::uint64_t getNativeCommandMonoTime();
  inline void setNativeCommandMonoTime( ::uint64_t value);

  inline double getAnnouncedCoefficient();
  inline void setAnnouncedCoefficient(double 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 FordLearningEvent::Pipeline {
public:
  typedef FordLearningEvent 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 CentreApplicationWitness::Reader {
public:
  typedef CentreApplicationWitness 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  ::uint16_t getVersion() const;

  inline bool hasIdentity() const;
  inline  ::capnp::Text::Reader getIdentity() const;

  inline bool hasSourceEpoch() const;
  inline  ::capnp::Text::Reader getSourceEpoch() const;

  inline  ::uint64_t getControlMonoTime() const;

  inline  ::uint64_t getProfileSequence() const;

  inline bool hasActualCoordinates() const;
  inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Reader getActualCoordinates() const;

  inline bool hasBaselineRevision() const;
  inline  ::capnp::Text::Reader getBaselineRevision() const;

  inline bool hasPhysicalModelRevision() const;
  inline  ::capnp::Text::Reader getPhysicalModelRevision() const;

  inline  ::uint64_t getOriginalObservedMonoTime() const;

  inline  ::uint64_t getOriginalValidUntilMonoTime() const;

  inline double getBaselineFriction() const;

  inline double getActualFriction() 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 CentreApplicationWitness::Builder {
public:
  typedef CentreApplicationWitness 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  ::uint16_t getVersion();
  inline void setVersion( ::uint16_t value);

  inline bool hasIdentity();
  inline  ::capnp::Text::Builder getIdentity();
  inline void setIdentity( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initIdentity(unsigned int size);
  inline void adoptIdentity(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownIdentity();

  inline bool hasSourceEpoch();
  inline  ::capnp::Text::Builder getSourceEpoch();
  inline void setSourceEpoch( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initSourceEpoch(unsigned int size);
  inline void adoptSourceEpoch(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownSourceEpoch();

  inline  ::uint64_t getControlMonoTime();
  inline void setControlMonoTime( ::uint64_t value);

  inline  ::uint64_t getProfileSequence();
  inline void setProfileSequence( ::uint64_t value);

  inline bool hasActualCoordinates();
  inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Builder getActualCoordinates();
  inline void setActualCoordinates( ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Reader value);
  inline void setActualCoordinates(::kj::ArrayPtr<const double> value);
  inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Builder initActualCoordinates(unsigned int size);
  inline void adoptActualCoordinates(::capnp::Orphan< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>&& value);
  inline ::capnp::Orphan< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>> disownActualCoordinates();

  inline bool hasBaselineRevision();
  inline  ::capnp::Text::Builder getBaselineRevision();
  inline void setBaselineRevision( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initBaselineRevision(unsigned int size);
  inline void adoptBaselineRevision(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownBaselineRevision();

  inline bool hasPhysicalModelRevision();
  inline  ::capnp::Text::Builder getPhysicalModelRevision();
  inline void setPhysicalModelRevision( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initPhysicalModelRevision(unsigned int size);
  inline void adoptPhysicalModelRevision(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownPhysicalModelRevision();

  inline  ::uint64_t getOriginalObservedMonoTime();
  inline void setOriginalObservedMonoTime( ::uint64_t value);

  inline  ::uint64_t getOriginalValidUntilMonoTime();
  inline void setOriginalValidUntilMonoTime( ::uint64_t value);

  inline double getBaselineFriction();
  inline void setBaselineFriction(double value);

  inline double getActualFriction();
  inline void setActualFriction(double 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 CentreApplicationWitness::Pipeline {
public:
  typedef CentreApplicationWitness 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 LearningTorqueProjection::Reader {
public:
  typedef LearningTorqueProjection 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  ::uint16_t getVersion() const;

  inline bool hasFamily() const;
  inline  ::capnp::Text::Reader getFamily() const;

  inline bool hasFingerprint() const;
  inline  ::capnp::Text::Reader getFingerprint() const;

  inline  ::uint64_t getFlags() const;

  inline bool hasCodecId() const;
  inline  ::capnp::Text::Reader getCodecId() const;

  inline bool hasMappingKind() const;
  inline  ::capnp::Text::Reader getMappingKind() const;

  inline  ::uint64_t getFrame() const;

  inline double getRequestedTorque() const;

  inline double getCodecInputTorque() const;

  inline  ::int32_t getUnlimitedRaw() const;

  inline  ::int32_t getFinalRaw() const;

  inline double getEffectiveMax() const;

  inline bool hasLookupX() const;
  inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Reader getLookupX() const;

  inline bool hasLookupY() const;
  inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Reader getLookupY() const;

  inline bool hasLimiterKind() const;
  inline  ::capnp::Text::Reader getLimiterKind() const;

  inline double getPreviousTorque() const;

  inline double getMeasuredTorque() const;

  inline bool hasLimits() const;
  inline  ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>::Reader getLimits() const;

  inline bool hasShape() const;
  inline  ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>::Reader getShape() const;

  inline bool getSteerRequested() const;

  inline  ::uint32_t getCanAddress() const;

  inline  ::uint16_t getCanBus() const;

  inline bool hasCanData() const;
  inline  ::capnp::Data::Reader getCanData() const;

  inline double getReportedTorque() const;

  inline bool getUnlimitedRawPresent() 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 LearningTorqueProjection::Builder {
public:
  typedef LearningTorqueProjection 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  ::uint16_t getVersion();
  inline void setVersion( ::uint16_t value);

  inline bool hasFamily();
  inline  ::capnp::Text::Builder getFamily();
  inline void setFamily( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initFamily(unsigned int size);
  inline void adoptFamily(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownFamily();

  inline bool hasFingerprint();
  inline  ::capnp::Text::Builder getFingerprint();
  inline void setFingerprint( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initFingerprint(unsigned int size);
  inline void adoptFingerprint(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownFingerprint();

  inline  ::uint64_t getFlags();
  inline void setFlags( ::uint64_t value);

  inline bool hasCodecId();
  inline  ::capnp::Text::Builder getCodecId();
  inline void setCodecId( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initCodecId(unsigned int size);
  inline void adoptCodecId(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownCodecId();

  inline bool hasMappingKind();
  inline  ::capnp::Text::Builder getMappingKind();
  inline void setMappingKind( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initMappingKind(unsigned int size);
  inline void adoptMappingKind(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownMappingKind();

  inline  ::uint64_t getFrame();
  inline void setFrame( ::uint64_t value);

  inline double getRequestedTorque();
  inline void setRequestedTorque(double value);

  inline double getCodecInputTorque();
  inline void setCodecInputTorque(double value);

  inline  ::int32_t getUnlimitedRaw();
  inline void setUnlimitedRaw( ::int32_t value);

  inline  ::int32_t getFinalRaw();
  inline void setFinalRaw( ::int32_t value);

  inline double getEffectiveMax();
  inline void setEffectiveMax(double value);

  inline bool hasLookupX();
  inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Builder getLookupX();
  inline void setLookupX( ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Reader value);
  inline void setLookupX(::kj::ArrayPtr<const double> value);
  inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Builder initLookupX(unsigned int size);
  inline void adoptLookupX(::capnp::Orphan< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>&& value);
  inline ::capnp::Orphan< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>> disownLookupX();

  inline bool hasLookupY();
  inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Builder getLookupY();
  inline void setLookupY( ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Reader value);
  inline void setLookupY(::kj::ArrayPtr<const double> value);
  inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Builder initLookupY(unsigned int size);
  inline void adoptLookupY(::capnp::Orphan< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>&& value);
  inline ::capnp::Orphan< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>> disownLookupY();

  inline bool hasLimiterKind();
  inline  ::capnp::Text::Builder getLimiterKind();
  inline void setLimiterKind( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initLimiterKind(unsigned int size);
  inline void adoptLimiterKind(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownLimiterKind();

  inline double getPreviousTorque();
  inline void setPreviousTorque(double value);

  inline double getMeasuredTorque();
  inline void setMeasuredTorque(double value);

  inline bool hasLimits();
  inline  ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>::Builder getLimits();
  inline void setLimits( ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>::Reader value);
  inline  ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>::Builder initLimits(unsigned int size);
  inline void adoptLimits(::capnp::Orphan< ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>>&& value);
  inline ::capnp::Orphan< ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>> disownLimits();

  inline bool hasShape();
  inline  ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>::Builder getShape();
  inline void setShape( ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>::Reader value);
  inline  ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>::Builder initShape(unsigned int size);
  inline void adoptShape(::capnp::Orphan< ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>>&& value);
  inline ::capnp::Orphan< ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>> disownShape();

  inline bool getSteerRequested();
  inline void setSteerRequested(bool value);

  inline  ::uint32_t getCanAddress();
  inline void setCanAddress( ::uint32_t value);

  inline  ::uint16_t getCanBus();
  inline void setCanBus( ::uint16_t value);

  inline bool hasCanData();
  inline  ::capnp::Data::Builder getCanData();
  inline void setCanData( ::capnp::Data::Reader value);
  inline  ::capnp::Data::Builder initCanData(unsigned int size);
  inline void adoptCanData(::capnp::Orphan< ::capnp::Data>&& value);
  inline ::capnp::Orphan< ::capnp::Data> disownCanData();

  inline double getReportedTorque();
  inline void setReportedTorque(double value);

  inline bool getUnlimitedRawPresent();
  inline void setUnlimitedRawPresent(bool 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 LearningTorqueProjection::Pipeline {
public:
  typedef LearningTorqueProjection 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 LiveTrackingBinding::Reader {
public:
  typedef LiveTrackingBinding 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 hasIdentity() const;
  inline  ::capnp::Text::Reader getIdentity() const;

  inline bool hasCpSha256() const;
  inline  ::capnp::Text::Reader getCpSha256() const;

  inline bool hasControllerRevision() const;
  inline  ::capnp::Text::Reader getControllerRevision() const;

  inline bool hasBaselineRevision() const;
  inline  ::capnp::Text::Reader getBaselineRevision() const;

  inline bool hasSourceEpoch() const;
  inline  ::capnp::Text::Reader getSourceEpoch() const;

  inline bool hasResetGeneration() const;
  inline  ::capnp::Text::Reader getResetGeneration() const;

  inline bool hasCalibrationGeneration() const;
  inline  ::capnp::Text::Reader getCalibrationGeneration() const;

  inline bool hasVehicleModelGeneration() const;
  inline  ::capnp::Text::Reader getVehicleModelGeneration() const;

  inline bool hasNativeIdentity() const;
  inline  ::capnp::Text::Reader getNativeIdentity() const;

  inline bool hasPhysicalModelRevision() const;
  inline  ::capnp::Text::Reader getPhysicalModelRevision() const;

  inline bool hasPersistentSourceEpoch() const;
  inline  ::capnp::Text::Reader getPersistentSourceEpoch() const;

  inline bool getNativeRequired() 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 LiveTrackingBinding::Builder {
public:
  typedef LiveTrackingBinding 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 hasIdentity();
  inline  ::capnp::Text::Builder getIdentity();
  inline void setIdentity( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initIdentity(unsigned int size);
  inline void adoptIdentity(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownIdentity();

  inline bool hasCpSha256();
  inline  ::capnp::Text::Builder getCpSha256();
  inline void setCpSha256( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initCpSha256(unsigned int size);
  inline void adoptCpSha256(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownCpSha256();

  inline bool hasControllerRevision();
  inline  ::capnp::Text::Builder getControllerRevision();
  inline void setControllerRevision( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initControllerRevision(unsigned int size);
  inline void adoptControllerRevision(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownControllerRevision();

  inline bool hasBaselineRevision();
  inline  ::capnp::Text::Builder getBaselineRevision();
  inline void setBaselineRevision( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initBaselineRevision(unsigned int size);
  inline void adoptBaselineRevision(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownBaselineRevision();

  inline bool hasSourceEpoch();
  inline  ::capnp::Text::Builder getSourceEpoch();
  inline void setSourceEpoch( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initSourceEpoch(unsigned int size);
  inline void adoptSourceEpoch(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownSourceEpoch();

  inline bool hasResetGeneration();
  inline  ::capnp::Text::Builder getResetGeneration();
  inline void setResetGeneration( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initResetGeneration(unsigned int size);
  inline void adoptResetGeneration(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownResetGeneration();

  inline bool hasCalibrationGeneration();
  inline  ::capnp::Text::Builder getCalibrationGeneration();
  inline void setCalibrationGeneration( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initCalibrationGeneration(unsigned int size);
  inline void adoptCalibrationGeneration(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownCalibrationGeneration();

  inline bool hasVehicleModelGeneration();
  inline  ::capnp::Text::Builder getVehicleModelGeneration();
  inline void setVehicleModelGeneration( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initVehicleModelGeneration(unsigned int size);
  inline void adoptVehicleModelGeneration(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownVehicleModelGeneration();

  inline bool hasNativeIdentity();
  inline  ::capnp::Text::Builder getNativeIdentity();
  inline void setNativeIdentity( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initNativeIdentity(unsigned int size);
  inline void adoptNativeIdentity(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownNativeIdentity();

  inline bool hasPhysicalModelRevision();
  inline  ::capnp::Text::Builder getPhysicalModelRevision();
  inline void setPhysicalModelRevision( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initPhysicalModelRevision(unsigned int size);
  inline void adoptPhysicalModelRevision(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownPhysicalModelRevision();

  inline bool hasPersistentSourceEpoch();
  inline  ::capnp::Text::Builder getPersistentSourceEpoch();
  inline void setPersistentSourceEpoch( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initPersistentSourceEpoch(unsigned int size);
  inline void adoptPersistentSourceEpoch(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownPersistentSourceEpoch();

  inline bool getNativeRequired();
  inline void setNativeRequired(bool 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 LiveTrackingBinding::Pipeline {
public:
  typedef LiveTrackingBinding 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 LiveTrackingTrial::Reader {
public:
  typedef LiveTrackingTrial 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  ::uint16_t getVersion() const;

  inline bool hasProtocol() const;
  inline  ::capnp::Text::Reader getProtocol() const;

  inline bool hasBinding() const;
  inline  ::cereal::LiveTrackingBinding::Reader getBinding() const;

  inline bool hasTrialId() const;
  inline  ::capnp::Text::Reader getTrialId() const;

  inline  ::uint64_t getSequence() const;

  inline bool hasPhase() const;
  inline  ::capnp::Text::Reader getPhase() const;

  inline bool hasGroup() const;
  inline  ::capnp::Text::Reader getGroup() const;

  inline bool hasNames() const;
  inline  ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>::Reader getNames() const;

  inline bool hasBaseline() const;
  inline  ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>::Reader getBaseline() const;

  inline bool hasTarget() const;
  inline  ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>::Reader getTarget() const;

  inline bool hasBaselineSha256() const;
  inline  ::capnp::Text::Reader getBaselineSha256() const;

  inline bool hasTargetSha256() const;
  inline  ::capnp::Text::Reader getTargetSha256() const;

  inline  ::uint64_t getStartedMonoTime() const;

  inline  ::uint64_t getObservedMonoTime() const;

  inline  ::uint64_t getValidUntilMonoTime() const;

  inline bool hasResponseWitness() const;
  inline  ::cereal::LiveTrackingResponseWitness::Reader getResponseWitness() const;

  inline  ::uint64_t getTargetSequence() const;

  inline  ::uint64_t getDeadlineMonoTime() 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 LiveTrackingTrial::Builder {
public:
  typedef LiveTrackingTrial 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  ::uint16_t getVersion();
  inline void setVersion( ::uint16_t value);

  inline bool hasProtocol();
  inline  ::capnp::Text::Builder getProtocol();
  inline void setProtocol( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initProtocol(unsigned int size);
  inline void adoptProtocol(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownProtocol();

  inline bool hasBinding();
  inline  ::cereal::LiveTrackingBinding::Builder getBinding();
  inline void setBinding( ::cereal::LiveTrackingBinding::Reader value);
  inline  ::cereal::LiveTrackingBinding::Builder initBinding();
  inline void adoptBinding(::capnp::Orphan< ::cereal::LiveTrackingBinding>&& value);
  inline ::capnp::Orphan< ::cereal::LiveTrackingBinding> disownBinding();

  inline bool hasTrialId();
  inline  ::capnp::Text::Builder getTrialId();
  inline void setTrialId( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initTrialId(unsigned int size);
  inline void adoptTrialId(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownTrialId();

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

  inline bool hasPhase();
  inline  ::capnp::Text::Builder getPhase();
  inline void setPhase( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initPhase(unsigned int size);
  inline void adoptPhase(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownPhase();

  inline bool hasGroup();
  inline  ::capnp::Text::Builder getGroup();
  inline void setGroup( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initGroup(unsigned int size);
  inline void adoptGroup(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownGroup();

  inline bool hasNames();
  inline  ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>::Builder getNames();
  inline void setNames( ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>::Reader value);
  inline void setNames(::kj::ArrayPtr<const  ::capnp::Text::Reader> value);
  inline  ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>::Builder initNames(unsigned int size);
  inline void adoptNames(::capnp::Orphan< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>&& value);
  inline ::capnp::Orphan< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>> disownNames();

  inline bool hasBaseline();
  inline  ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>::Builder getBaseline();
  inline void setBaseline( ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>::Reader value);
  inline  ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>::Builder initBaseline(unsigned int size);
  inline void adoptBaseline(::capnp::Orphan< ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>>&& value);
  inline ::capnp::Orphan< ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>> disownBaseline();

  inline bool hasTarget();
  inline  ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>::Builder getTarget();
  inline void setTarget( ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>::Reader value);
  inline  ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>::Builder initTarget(unsigned int size);
  inline void adoptTarget(::capnp::Orphan< ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>>&& value);
  inline ::capnp::Orphan< ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>> disownTarget();

  inline bool hasBaselineSha256();
  inline  ::capnp::Text::Builder getBaselineSha256();
  inline void setBaselineSha256( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initBaselineSha256(unsigned int size);
  inline void adoptBaselineSha256(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownBaselineSha256();

  inline bool hasTargetSha256();
  inline  ::capnp::Text::Builder getTargetSha256();
  inline void setTargetSha256( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initTargetSha256(unsigned int size);
  inline void adoptTargetSha256(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownTargetSha256();

  inline  ::uint64_t getStartedMonoTime();
  inline void setStartedMonoTime( ::uint64_t value);

  inline  ::uint64_t getObservedMonoTime();
  inline void setObservedMonoTime( ::uint64_t value);

  inline  ::uint64_t getValidUntilMonoTime();
  inline void setValidUntilMonoTime( ::uint64_t value);

  inline bool hasResponseWitness();
  inline  ::cereal::LiveTrackingResponseWitness::Builder getResponseWitness();
  inline void setResponseWitness( ::cereal::LiveTrackingResponseWitness::Reader value);
  inline  ::cereal::LiveTrackingResponseWitness::Builder initResponseWitness();
  inline void adoptResponseWitness(::capnp::Orphan< ::cereal::LiveTrackingResponseWitness>&& value);
  inline ::capnp::Orphan< ::cereal::LiveTrackingResponseWitness> disownResponseWitness();

  inline  ::uint64_t getTargetSequence();
  inline void setTargetSequence( ::uint64_t value);

  inline  ::uint64_t getDeadlineMonoTime();
  inline void setDeadlineMonoTime( ::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 LiveTrackingTrial::Pipeline {
public:
  typedef LiveTrackingTrial Pipelines;

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

  inline  ::cereal::LiveTrackingBinding::Pipeline getBinding();
  inline  ::cereal::LiveTrackingResponseWitness::Pipeline getResponseWitness();
private:
  ::capnp::AnyPointer::Pipeline _typeless;
  friend class ::capnp::PipelineHook;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
};
#endif  // !CAPNP_LITE

class LiveTrackingTrial::Coordinate::Reader {
public:
  typedef Coordinate 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 hasName() const;
  inline  ::capnp::Text::Reader getName() const;

  inline double getValue() 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 LiveTrackingTrial::Coordinate::Builder {
public:
  typedef Coordinate 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 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 double getValue();
  inline void setValue(double 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 LiveTrackingTrial::Coordinate::Pipeline {
public:
  typedef Coordinate 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 LiveTrackingApplication::Reader {
public:
  typedef LiveTrackingApplication 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  ::uint16_t getVersion() const;

  inline bool hasBinding() const;
  inline  ::cereal::LiveTrackingBinding::Reader getBinding() const;

  inline bool hasTrialId() const;
  inline  ::capnp::Text::Reader getTrialId() const;

  inline  ::uint64_t getSequence() const;

  inline  ::uint64_t getControlMonoTime() const;

  inline bool hasStatus() const;
  inline  ::capnp::Text::Reader getStatus() const;

  inline bool hasApplied() const;
  inline  ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>::Reader getApplied() const;

  inline bool hasAppliedSha256() const;
  inline  ::capnp::Text::Reader getAppliedSha256() const;

  inline bool hasConfirmedTargetSha256() const;
  inline  ::capnp::Text::Reader getConfirmedTargetSha256() const;

  inline bool hasReason() const;
  inline  ::capnp::Text::Reader getReason() const;

  inline  ::uint64_t getTargetSequence() 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 LiveTrackingApplication::Builder {
public:
  typedef LiveTrackingApplication 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  ::uint16_t getVersion();
  inline void setVersion( ::uint16_t value);

  inline bool hasBinding();
  inline  ::cereal::LiveTrackingBinding::Builder getBinding();
  inline void setBinding( ::cereal::LiveTrackingBinding::Reader value);
  inline  ::cereal::LiveTrackingBinding::Builder initBinding();
  inline void adoptBinding(::capnp::Orphan< ::cereal::LiveTrackingBinding>&& value);
  inline ::capnp::Orphan< ::cereal::LiveTrackingBinding> disownBinding();

  inline bool hasTrialId();
  inline  ::capnp::Text::Builder getTrialId();
  inline void setTrialId( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initTrialId(unsigned int size);
  inline void adoptTrialId(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownTrialId();

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

  inline  ::uint64_t getControlMonoTime();
  inline void setControlMonoTime( ::uint64_t value);

  inline bool hasStatus();
  inline  ::capnp::Text::Builder getStatus();
  inline void setStatus( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initStatus(unsigned int size);
  inline void adoptStatus(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownStatus();

  inline bool hasApplied();
  inline  ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>::Builder getApplied();
  inline void setApplied( ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>::Reader value);
  inline  ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>::Builder initApplied(unsigned int size);
  inline void adoptApplied(::capnp::Orphan< ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>>&& value);
  inline ::capnp::Orphan< ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>> disownApplied();

  inline bool hasAppliedSha256();
  inline  ::capnp::Text::Builder getAppliedSha256();
  inline void setAppliedSha256( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initAppliedSha256(unsigned int size);
  inline void adoptAppliedSha256(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownAppliedSha256();

  inline bool hasConfirmedTargetSha256();
  inline  ::capnp::Text::Builder getConfirmedTargetSha256();
  inline void setConfirmedTargetSha256( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initConfirmedTargetSha256(unsigned int size);
  inline void adoptConfirmedTargetSha256(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownConfirmedTargetSha256();

  inline bool hasReason();
  inline  ::capnp::Text::Builder getReason();
  inline void setReason( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initReason(unsigned int size);
  inline void adoptReason(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownReason();

  inline  ::uint64_t getTargetSequence();
  inline void setTargetSequence( ::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 LiveTrackingApplication::Pipeline {
public:
  typedef LiveTrackingApplication Pipelines;

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

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

class LiveTrackingRestore::Reader {
public:
  typedef LiveTrackingRestore 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  ::uint16_t getVersion() const;

  inline bool hasProtocol() const;
  inline  ::capnp::Text::Reader getProtocol() const;

  inline bool hasBinding() const;
  inline  ::cereal::LiveTrackingBinding::Reader getBinding() const;

  inline bool hasHistoryScope() const;
  inline  ::capnp::Text::Reader getHistoryScope() const;

  inline bool hasHistoryTrialId() const;
  inline  ::capnp::Text::Reader getHistoryTrialId() const;

  inline bool hasTarget() const;
  inline  ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>::Reader getTarget() const;

  inline bool hasTargetSha256() const;
  inline  ::capnp::Text::Reader getTargetSha256() const;

  inline  ::uint64_t getSequence() const;

  inline  ::uint64_t getObservedMonoTime() const;

  inline  ::uint64_t getValidUntilMonoTime() const;

  inline bool hasResponseWitness() const;
  inline  ::cereal::LiveTrackingResponseWitness::Reader getResponseWitness() 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 LiveTrackingRestore::Builder {
public:
  typedef LiveTrackingRestore 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  ::uint16_t getVersion();
  inline void setVersion( ::uint16_t value);

  inline bool hasProtocol();
  inline  ::capnp::Text::Builder getProtocol();
  inline void setProtocol( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initProtocol(unsigned int size);
  inline void adoptProtocol(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownProtocol();

  inline bool hasBinding();
  inline  ::cereal::LiveTrackingBinding::Builder getBinding();
  inline void setBinding( ::cereal::LiveTrackingBinding::Reader value);
  inline  ::cereal::LiveTrackingBinding::Builder initBinding();
  inline void adoptBinding(::capnp::Orphan< ::cereal::LiveTrackingBinding>&& value);
  inline ::capnp::Orphan< ::cereal::LiveTrackingBinding> disownBinding();

  inline bool hasHistoryScope();
  inline  ::capnp::Text::Builder getHistoryScope();
  inline void setHistoryScope( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initHistoryScope(unsigned int size);
  inline void adoptHistoryScope(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownHistoryScope();

  inline bool hasHistoryTrialId();
  inline  ::capnp::Text::Builder getHistoryTrialId();
  inline void setHistoryTrialId( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initHistoryTrialId(unsigned int size);
  inline void adoptHistoryTrialId(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownHistoryTrialId();

  inline bool hasTarget();
  inline  ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>::Builder getTarget();
  inline void setTarget( ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>::Reader value);
  inline  ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>::Builder initTarget(unsigned int size);
  inline void adoptTarget(::capnp::Orphan< ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>>&& value);
  inline ::capnp::Orphan< ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>> disownTarget();

  inline bool hasTargetSha256();
  inline  ::capnp::Text::Builder getTargetSha256();
  inline void setTargetSha256( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initTargetSha256(unsigned int size);
  inline void adoptTargetSha256(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownTargetSha256();

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

  inline  ::uint64_t getObservedMonoTime();
  inline void setObservedMonoTime( ::uint64_t value);

  inline  ::uint64_t getValidUntilMonoTime();
  inline void setValidUntilMonoTime( ::uint64_t value);

  inline bool hasResponseWitness();
  inline  ::cereal::LiveTrackingResponseWitness::Builder getResponseWitness();
  inline void setResponseWitness( ::cereal::LiveTrackingResponseWitness::Reader value);
  inline  ::cereal::LiveTrackingResponseWitness::Builder initResponseWitness();
  inline void adoptResponseWitness(::capnp::Orphan< ::cereal::LiveTrackingResponseWitness>&& value);
  inline ::capnp::Orphan< ::cereal::LiveTrackingResponseWitness> disownResponseWitness();

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 LiveTrackingRestore::Pipeline {
public:
  typedef LiveTrackingRestore Pipelines;

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

  inline  ::cereal::LiveTrackingBinding::Pipeline getBinding();
  inline  ::cereal::LiveTrackingResponseWitness::Pipeline getResponseWitness();
private:
  ::capnp::AnyPointer::Pipeline _typeless;
  friend class ::capnp::PipelineHook;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
};
#endif  // !CAPNP_LITE

class LiveTrackingResponseCertificate::Reader {
public:
  typedef LiveTrackingResponseCertificate 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 hasVersion() const;
  inline  ::capnp::Text::Reader getVersion() const;

  inline bool hasModelRevision() const;
  inline  ::capnp::Text::Reader getModelRevision() const;

  inline  ::uint64_t getLagNs() const;

  inline double getSlope() const;

  inline double getIntercept() const;

  inline double getCommandLow() const;

  inline double getCommandHigh() const;

  inline double getHeldoutRmse() const;

  inline bool hasTrainBlockIds() const;
  inline  ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>::Reader getTrainBlockIds() const;

  inline bool hasHeldoutBlockIds() const;
  inline  ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>::Reader getHeldoutBlockIds() const;

  inline bool hasSourceInventorySha256() const;
  inline  ::capnp::Text::Reader getSourceInventorySha256() const;

  inline bool hasIdentificationSha256() const;
  inline  ::capnp::Text::Reader getIdentificationSha256() const;

  inline  ::uint64_t getIdentifiedMonoTime() const;

  inline bool hasProvenance() const;
  inline  ::capnp::Text::Reader getProvenance() const;

  inline bool hasParentModelRevision() const;
  inline  ::capnp::Text::Reader getParentModelRevision() const;

  inline bool hasRequalificationSha256() const;
  inline  ::capnp::Text::Reader getRequalificationSha256() 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 LiveTrackingResponseCertificate::Builder {
public:
  typedef LiveTrackingResponseCertificate 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 hasVersion();
  inline  ::capnp::Text::Builder getVersion();
  inline void setVersion( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initVersion(unsigned int size);
  inline void adoptVersion(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownVersion();

  inline bool hasModelRevision();
  inline  ::capnp::Text::Builder getModelRevision();
  inline void setModelRevision( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initModelRevision(unsigned int size);
  inline void adoptModelRevision(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownModelRevision();

  inline  ::uint64_t getLagNs();
  inline void setLagNs( ::uint64_t value);

  inline double getSlope();
  inline void setSlope(double value);

  inline double getIntercept();
  inline void setIntercept(double value);

  inline double getCommandLow();
  inline void setCommandLow(double value);

  inline double getCommandHigh();
  inline void setCommandHigh(double value);

  inline double getHeldoutRmse();
  inline void setHeldoutRmse(double value);

  inline bool hasTrainBlockIds();
  inline  ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>::Builder getTrainBlockIds();
  inline void setTrainBlockIds( ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>::Reader value);
  inline void setTrainBlockIds(::kj::ArrayPtr<const  ::capnp::Text::Reader> value);
  inline  ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>::Builder initTrainBlockIds(unsigned int size);
  inline void adoptTrainBlockIds(::capnp::Orphan< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>&& value);
  inline ::capnp::Orphan< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>> disownTrainBlockIds();

  inline bool hasHeldoutBlockIds();
  inline  ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>::Builder getHeldoutBlockIds();
  inline void setHeldoutBlockIds( ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>::Reader value);
  inline void setHeldoutBlockIds(::kj::ArrayPtr<const  ::capnp::Text::Reader> value);
  inline  ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>::Builder initHeldoutBlockIds(unsigned int size);
  inline void adoptHeldoutBlockIds(::capnp::Orphan< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>&& value);
  inline ::capnp::Orphan< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>> disownHeldoutBlockIds();

  inline bool hasSourceInventorySha256();
  inline  ::capnp::Text::Builder getSourceInventorySha256();
  inline void setSourceInventorySha256( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initSourceInventorySha256(unsigned int size);
  inline void adoptSourceInventorySha256(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownSourceInventorySha256();

  inline bool hasIdentificationSha256();
  inline  ::capnp::Text::Builder getIdentificationSha256();
  inline void setIdentificationSha256( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initIdentificationSha256(unsigned int size);
  inline void adoptIdentificationSha256(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownIdentificationSha256();

  inline  ::uint64_t getIdentifiedMonoTime();
  inline void setIdentifiedMonoTime( ::uint64_t value);

  inline bool hasProvenance();
  inline  ::capnp::Text::Builder getProvenance();
  inline void setProvenance( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initProvenance(unsigned int size);
  inline void adoptProvenance(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownProvenance();

  inline bool hasParentModelRevision();
  inline  ::capnp::Text::Builder getParentModelRevision();
  inline void setParentModelRevision( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initParentModelRevision(unsigned int size);
  inline void adoptParentModelRevision(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownParentModelRevision();

  inline bool hasRequalificationSha256();
  inline  ::capnp::Text::Builder getRequalificationSha256();
  inline void setRequalificationSha256( ::capnp::Text::Reader value);
  inline  ::capnp::Text::Builder initRequalificationSha256(unsigned int size);
  inline void adoptRequalificationSha256(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownRequalificationSha256();

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 LiveTrackingResponseCertificate::Pipeline {
public:
  typedef LiveTrackingResponseCertificate 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 LiveTrackingResponseWitness::Reader {
public:
  typedef LiveTrackingResponseWitness 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 hasCertificate() const;
  inline  ::cereal::LiveTrackingResponseCertificate::Reader getCertificate() const;

  inline  ::uint64_t getLastControlMonoTime() const;

  inline  ::uint64_t getLastApplyMonoTime() const;

  inline  ::uint64_t getLastPoseMonoTime() const;

  inline  ::uint64_t getWindowStartMonoTime() const;

  inline  ::uint16_t getIndependentPoses() const;

  inline double getResidualRmse() const;

  inline  ::uint64_t getValidUntilMonoTime() 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 LiveTrackingResponseWitness::Builder {
public:
  typedef LiveTrackingResponseWitness 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 hasCertificate();
  inline  ::cereal::LiveTrackingResponseCertificate::Builder getCertificate();
  inline void setCertificate( ::cereal::LiveTrackingResponseCertificate::Reader value);
  inline  ::cereal::LiveTrackingResponseCertificate::Builder initCertificate();
  inline void adoptCertificate(::capnp::Orphan< ::cereal::LiveTrackingResponseCertificate>&& value);
  inline ::capnp::Orphan< ::cereal::LiveTrackingResponseCertificate> disownCertificate();

  inline  ::uint64_t getLastControlMonoTime();
  inline void setLastControlMonoTime( ::uint64_t value);

  inline  ::uint64_t getLastApplyMonoTime();
  inline void setLastApplyMonoTime( ::uint64_t value);

  inline  ::uint64_t getLastPoseMonoTime();
  inline void setLastPoseMonoTime( ::uint64_t value);

  inline  ::uint64_t getWindowStartMonoTime();
  inline void setWindowStartMonoTime( ::uint64_t value);

  inline  ::uint16_t getIndependentPoses();
  inline void setIndependentPoses( ::uint16_t value);

  inline double getResidualRmse();
  inline void setResidualRmse(double value);

  inline  ::uint64_t getValidUntilMonoTime();
  inline void setValidUntilMonoTime( ::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 LiveTrackingResponseWitness::Pipeline {
public:
  typedef LiveTrackingResponseWitness Pipelines;

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

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

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

inline bool StarPilotCarControl::Reader::hasHudControl() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotCarControl::Builder::hasHudControl() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::cereal::StarPilotCarControl::HUDControl::Reader StarPilotCarControl::Reader::getHudControl() const {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotCarControl::HUDControl>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::cereal::StarPilotCarControl::HUDControl::Builder StarPilotCarControl::Builder::getHudControl() {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotCarControl::HUDControl>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
#if !CAPNP_LITE
inline  ::cereal::StarPilotCarControl::HUDControl::Pipeline StarPilotCarControl::Pipeline::getHudControl() {
  return  ::cereal::StarPilotCarControl::HUDControl::Pipeline(_typeless.getPointerField(0));
}
#endif  // !CAPNP_LITE
inline void StarPilotCarControl::Builder::setHudControl( ::cereal::StarPilotCarControl::HUDControl::Reader value) {
  ::capnp::_::PointerHelpers< ::cereal::StarPilotCarControl::HUDControl>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::cereal::StarPilotCarControl::HUDControl::Builder StarPilotCarControl::Builder::initHudControl() {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotCarControl::HUDControl>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void StarPilotCarControl::Builder::adoptHudControl(
    ::capnp::Orphan< ::cereal::StarPilotCarControl::HUDControl>&& value) {
  ::capnp::_::PointerHelpers< ::cereal::StarPilotCarControl::HUDControl>::adopt(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::cereal::StarPilotCarControl::HUDControl> StarPilotCarControl::Builder::disownHudControl() {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotCarControl::HUDControl>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline bool StarPilotCarControl::Reader::hasSteeringLimitInfo() const {
  return !_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotCarControl::Builder::hasSteeringLimitInfo() {
  return !_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline  ::cereal::StarPilotCarControl::SteeringLimitInfo::Reader StarPilotCarControl::Reader::getSteeringLimitInfo() const {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotCarControl::SteeringLimitInfo>::get(_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline  ::cereal::StarPilotCarControl::SteeringLimitInfo::Builder StarPilotCarControl::Builder::getSteeringLimitInfo() {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotCarControl::SteeringLimitInfo>::get(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
#if !CAPNP_LITE
inline  ::cereal::StarPilotCarControl::SteeringLimitInfo::Pipeline StarPilotCarControl::Pipeline::getSteeringLimitInfo() {
  return  ::cereal::StarPilotCarControl::SteeringLimitInfo::Pipeline(_typeless.getPointerField(1));
}
#endif  // !CAPNP_LITE
inline void StarPilotCarControl::Builder::setSteeringLimitInfo( ::cereal::StarPilotCarControl::SteeringLimitInfo::Reader value) {
  ::capnp::_::PointerHelpers< ::cereal::StarPilotCarControl::SteeringLimitInfo>::set(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), value);
}
inline  ::cereal::StarPilotCarControl::SteeringLimitInfo::Builder StarPilotCarControl::Builder::initSteeringLimitInfo() {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotCarControl::SteeringLimitInfo>::init(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline void StarPilotCarControl::Builder::adoptSteeringLimitInfo(
    ::capnp::Orphan< ::cereal::StarPilotCarControl::SteeringLimitInfo>&& value) {
  ::capnp::_::PointerHelpers< ::cereal::StarPilotCarControl::SteeringLimitInfo>::adopt(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::cereal::StarPilotCarControl::SteeringLimitInfo> StarPilotCarControl::Builder::disownSteeringLimitInfo() {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotCarControl::SteeringLimitInfo>::disown(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}

inline bool StarPilotCarControl::Reader::hasNavigation() const {
  return !_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotCarControl::Builder::hasNavigation() {
  return !_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline  ::cereal::StarPilotCarControl::Navigation::Reader StarPilotCarControl::Reader::getNavigation() const {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotCarControl::Navigation>::get(_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline  ::cereal::StarPilotCarControl::Navigation::Builder StarPilotCarControl::Builder::getNavigation() {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotCarControl::Navigation>::get(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
#if !CAPNP_LITE
inline  ::cereal::StarPilotCarControl::Navigation::Pipeline StarPilotCarControl::Pipeline::getNavigation() {
  return  ::cereal::StarPilotCarControl::Navigation::Pipeline(_typeless.getPointerField(2));
}
#endif  // !CAPNP_LITE
inline void StarPilotCarControl::Builder::setNavigation( ::cereal::StarPilotCarControl::Navigation::Reader value) {
  ::capnp::_::PointerHelpers< ::cereal::StarPilotCarControl::Navigation>::set(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), value);
}
inline  ::cereal::StarPilotCarControl::Navigation::Builder StarPilotCarControl::Builder::initNavigation() {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotCarControl::Navigation>::init(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline void StarPilotCarControl::Builder::adoptNavigation(
    ::capnp::Orphan< ::cereal::StarPilotCarControl::Navigation>&& value) {
  ::capnp::_::PointerHelpers< ::cereal::StarPilotCarControl::Navigation>::adopt(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::cereal::StarPilotCarControl::Navigation> StarPilotCarControl::Builder::disownNavigation() {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotCarControl::Navigation>::disown(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}

inline bool StarPilotCarControl::Reader::hasPhoneGps() const {
  return !_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotCarControl::Builder::hasPhoneGps() {
  return !_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline  ::cereal::StarPilotCarState::Gps::Reader StarPilotCarControl::Reader::getPhoneGps() const {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotCarState::Gps>::get(_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline  ::cereal::StarPilotCarState::Gps::Builder StarPilotCarControl::Builder::getPhoneGps() {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotCarState::Gps>::get(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
#if !CAPNP_LITE
inline  ::cereal::StarPilotCarState::Gps::Pipeline StarPilotCarControl::Pipeline::getPhoneGps() {
  return  ::cereal::StarPilotCarState::Gps::Pipeline(_typeless.getPointerField(3));
}
#endif  // !CAPNP_LITE
inline void StarPilotCarControl::Builder::setPhoneGps( ::cereal::StarPilotCarState::Gps::Reader value) {
  ::capnp::_::PointerHelpers< ::cereal::StarPilotCarState::Gps>::set(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), value);
}
inline  ::cereal::StarPilotCarState::Gps::Builder StarPilotCarControl::Builder::initPhoneGps() {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotCarState::Gps>::init(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline void StarPilotCarControl::Builder::adoptPhoneGps(
    ::capnp::Orphan< ::cereal::StarPilotCarState::Gps>&& value) {
  ::capnp::_::PointerHelpers< ::cereal::StarPilotCarState::Gps>::adopt(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::cereal::StarPilotCarState::Gps> StarPilotCarControl::Builder::disownPhoneGps() {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotCarState::Gps>::disown(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}

inline  ::cereal::StarPilotCarControl::HUDControl::AudibleAlert StarPilotCarControl::HUDControl::Reader::getAudibleAlert() const {
  return _reader.getDataField< ::cereal::StarPilotCarControl::HUDControl::AudibleAlert>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline  ::cereal::StarPilotCarControl::HUDControl::AudibleAlert StarPilotCarControl::HUDControl::Builder::getAudibleAlert() {
  return _builder.getDataField< ::cereal::StarPilotCarControl::HUDControl::AudibleAlert>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarControl::HUDControl::Builder::setAudibleAlert( ::cereal::StarPilotCarControl::HUDControl::AudibleAlert value) {
  _builder.setDataField< ::cereal::StarPilotCarControl::HUDControl::AudibleAlert>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotCarControl::SteeringLimitInfo::Reader::getValid() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline bool StarPilotCarControl::SteeringLimitInfo::Builder::getValid() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarControl::SteeringLimitInfo::Builder::setValid(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline float StarPilotCarControl::SteeringLimitInfo::Reader::getModelLimitErrorDeg() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline float StarPilotCarControl::SteeringLimitInfo::Builder::getModelLimitErrorDeg() {
  return _builder.getDataField<float>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarControl::SteeringLimitInfo::Builder::setModelLimitErrorDeg(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline float StarPilotCarControl::SteeringLimitInfo::Reader::getResumeLimitErrorDeg() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline float StarPilotCarControl::SteeringLimitInfo::Builder::getResumeLimitErrorDeg() {
  return _builder.getDataField<float>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarControl::SteeringLimitInfo::Builder::setResumeLimitErrorDeg(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline float StarPilotCarControl::SteeringLimitInfo::Reader::getCooperativeLimitErrorDeg() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}

inline float StarPilotCarControl::SteeringLimitInfo::Builder::getCooperativeLimitErrorDeg() {
  return _builder.getDataField<float>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarControl::SteeringLimitInfo::Builder::setCooperativeLimitErrorDeg(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS, value);
}

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

inline float StarPilotCarControl::SteeringLimitInfo::Builder::getCooperativeOffsetDeg() {
  return _builder.getDataField<float>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarControl::SteeringLimitInfo::Builder::setCooperativeOffsetDeg(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t StarPilotCarControl::SteeringLimitInfo::Reader::getMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t StarPilotCarControl::SteeringLimitInfo::Builder::getMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarControl::SteeringLimitInfo::Builder::setMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS, value);
}

inline float StarPilotCarControl::SteeringLimitInfo::Reader::getCombinedLimitErrorDeg() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}

inline float StarPilotCarControl::SteeringLimitInfo::Builder::getCombinedLimitErrorDeg() {
  return _builder.getDataField<float>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarControl::SteeringLimitInfo::Builder::setCombinedLimitErrorDeg(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotCarControl::Navigation::Reader::hasSessionId() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotCarControl::Navigation::Builder::hasSessionId() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader StarPilotCarControl::Navigation::Reader::getSessionId() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder StarPilotCarControl::Navigation::Builder::getSessionId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void StarPilotCarControl::Navigation::Builder::setSessionId( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder StarPilotCarControl::Navigation::Builder::initSessionId(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void StarPilotCarControl::Navigation::Builder::adoptSessionId(
    ::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> StarPilotCarControl::Navigation::Builder::disownSessionId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline  ::uint64_t StarPilotCarControl::Navigation::Reader::getFrameMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t StarPilotCarControl::Navigation::Builder::getFrameMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarControl::Navigation::Builder::setFrameMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t StarPilotCarControl::Navigation::Reader::getStartedMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t StarPilotCarControl::Navigation::Builder::getStartedMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarControl::Navigation::Builder::setStartedMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotCarControl::Navigation::Reader::hasRevision() const {
  return !_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotCarControl::Navigation::Builder::hasRevision() {
  return !_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader StarPilotCarControl::Navigation::Reader::getRevision() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder StarPilotCarControl::Navigation::Builder::getRevision() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline void StarPilotCarControl::Navigation::Builder::setRevision( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder StarPilotCarControl::Navigation::Builder::initRevision(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), size);
}
inline void StarPilotCarControl::Navigation::Builder::adoptRevision(
    ::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> StarPilotCarControl::Navigation::Builder::disownRevision() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}

inline bool StarPilotCarControl::Navigation::Reader::getEnabled() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<128>() * ::capnp::ELEMENTS);
}

inline bool StarPilotCarControl::Navigation::Builder::getEnabled() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<128>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarControl::Navigation::Builder::setEnabled(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<128>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotCarControl::Navigation::Reader::hasStatus() const {
  return !_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotCarControl::Navigation::Builder::hasStatus() {
  return !_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader StarPilotCarControl::Navigation::Reader::getStatus() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder StarPilotCarControl::Navigation::Builder::getStatus() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline void StarPilotCarControl::Navigation::Builder::setStatus( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder StarPilotCarControl::Navigation::Builder::initStatus(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), size);
}
inline void StarPilotCarControl::Navigation::Builder::adoptStatus(
    ::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> StarPilotCarControl::Navigation::Builder::disownStatus() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}

inline bool StarPilotCarControl::Navigation::Reader::hasDestinationName() const {
  return !_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotCarControl::Navigation::Builder::hasDestinationName() {
  return !_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader StarPilotCarControl::Navigation::Reader::getDestinationName() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder StarPilotCarControl::Navigation::Builder::getDestinationName() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline void StarPilotCarControl::Navigation::Builder::setDestinationName( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder StarPilotCarControl::Navigation::Builder::initDestinationName(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), size);
}
inline void StarPilotCarControl::Navigation::Builder::adoptDestinationName(
    ::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> StarPilotCarControl::Navigation::Builder::disownDestinationName() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}

inline bool StarPilotCarControl::Navigation::Reader::hasInstruction() const {
  return !_reader.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotCarControl::Navigation::Builder::hasInstruction() {
  return !_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS).isNull();
}
inline  ::cereal::StarPilotCarControl::Navigation::Instruction::Reader StarPilotCarControl::Navigation::Reader::getInstruction() const {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotCarControl::Navigation::Instruction>::get(_reader.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}
inline  ::cereal::StarPilotCarControl::Navigation::Instruction::Builder StarPilotCarControl::Navigation::Builder::getInstruction() {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotCarControl::Navigation::Instruction>::get(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}
#if !CAPNP_LITE
inline  ::cereal::StarPilotCarControl::Navigation::Instruction::Pipeline StarPilotCarControl::Navigation::Pipeline::getInstruction() {
  return  ::cereal::StarPilotCarControl::Navigation::Instruction::Pipeline(_typeless.getPointerField(4));
}
#endif  // !CAPNP_LITE
inline void StarPilotCarControl::Navigation::Builder::setInstruction( ::cereal::StarPilotCarControl::Navigation::Instruction::Reader value) {
  ::capnp::_::PointerHelpers< ::cereal::StarPilotCarControl::Navigation::Instruction>::set(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), value);
}
inline  ::cereal::StarPilotCarControl::Navigation::Instruction::Builder StarPilotCarControl::Navigation::Builder::initInstruction() {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotCarControl::Navigation::Instruction>::init(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}
inline void StarPilotCarControl::Navigation::Builder::adoptInstruction(
    ::capnp::Orphan< ::cereal::StarPilotCarControl::Navigation::Instruction>&& value) {
  ::capnp::_::PointerHelpers< ::cereal::StarPilotCarControl::Navigation::Instruction>::adopt(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::cereal::StarPilotCarControl::Navigation::Instruction> StarPilotCarControl::Navigation::Builder::disownInstruction() {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotCarControl::Navigation::Instruction>::disown(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}

inline bool StarPilotCarControl::Navigation::Reader::hasRoute() const {
  return !_reader.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotCarControl::Navigation::Builder::hasRoute() {
  return !_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::List< ::cereal::StarPilotCarControl::Navigation::Coordinate,  ::capnp::Kind::STRUCT>::Reader StarPilotCarControl::Navigation::Reader::getRoute() const {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::StarPilotCarControl::Navigation::Coordinate,  ::capnp::Kind::STRUCT>>::get(_reader.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS));
}
inline  ::capnp::List< ::cereal::StarPilotCarControl::Navigation::Coordinate,  ::capnp::Kind::STRUCT>::Builder StarPilotCarControl::Navigation::Builder::getRoute() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::StarPilotCarControl::Navigation::Coordinate,  ::capnp::Kind::STRUCT>>::get(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS));
}
inline void StarPilotCarControl::Navigation::Builder::setRoute( ::capnp::List< ::cereal::StarPilotCarControl::Navigation::Coordinate,  ::capnp::Kind::STRUCT>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::StarPilotCarControl::Navigation::Coordinate,  ::capnp::Kind::STRUCT>>::set(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS), value);
}
inline  ::capnp::List< ::cereal::StarPilotCarControl::Navigation::Coordinate,  ::capnp::Kind::STRUCT>::Builder StarPilotCarControl::Navigation::Builder::initRoute(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::StarPilotCarControl::Navigation::Coordinate,  ::capnp::Kind::STRUCT>>::init(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS), size);
}
inline void StarPilotCarControl::Navigation::Builder::adoptRoute(
    ::capnp::Orphan< ::capnp::List< ::cereal::StarPilotCarControl::Navigation::Coordinate,  ::capnp::Kind::STRUCT>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::StarPilotCarControl::Navigation::Coordinate,  ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List< ::cereal::StarPilotCarControl::Navigation::Coordinate,  ::capnp::Kind::STRUCT>> StarPilotCarControl::Navigation::Builder::disownRoute() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::StarPilotCarControl::Navigation::Coordinate,  ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS));
}

inline bool StarPilotCarControl::Navigation::Reader::hasNextManeuver() const {
  return !_reader.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotCarControl::Navigation::Builder::hasNextManeuver() {
  return !_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS).isNull();
}
inline  ::cereal::StarPilotCarControl::Navigation::Instruction::Reader StarPilotCarControl::Navigation::Reader::getNextManeuver() const {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotCarControl::Navigation::Instruction>::get(_reader.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS));
}
inline  ::cereal::StarPilotCarControl::Navigation::Instruction::Builder StarPilotCarControl::Navigation::Builder::getNextManeuver() {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotCarControl::Navigation::Instruction>::get(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS));
}
#if !CAPNP_LITE
inline  ::cereal::StarPilotCarControl::Navigation::Instruction::Pipeline StarPilotCarControl::Navigation::Pipeline::getNextManeuver() {
  return  ::cereal::StarPilotCarControl::Navigation::Instruction::Pipeline(_typeless.getPointerField(6));
}
#endif  // !CAPNP_LITE
inline void StarPilotCarControl::Navigation::Builder::setNextManeuver( ::cereal::StarPilotCarControl::Navigation::Instruction::Reader value) {
  ::capnp::_::PointerHelpers< ::cereal::StarPilotCarControl::Navigation::Instruction>::set(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS), value);
}
inline  ::cereal::StarPilotCarControl::Navigation::Instruction::Builder StarPilotCarControl::Navigation::Builder::initNextManeuver() {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotCarControl::Navigation::Instruction>::init(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS));
}
inline void StarPilotCarControl::Navigation::Builder::adoptNextManeuver(
    ::capnp::Orphan< ::cereal::StarPilotCarControl::Navigation::Instruction>&& value) {
  ::capnp::_::PointerHelpers< ::cereal::StarPilotCarControl::Navigation::Instruction>::adopt(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::cereal::StarPilotCarControl::Navigation::Instruction> StarPilotCarControl::Navigation::Builder::disownNextManeuver() {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotCarControl::Navigation::Instruction>::disown(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS));
}

inline  ::uint64_t StarPilotCarControl::Navigation::Reader::getLocationMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t StarPilotCarControl::Navigation::Builder::getLocationMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarControl::Navigation::Builder::setLocationMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotCarControl::Navigation::Reader::getControlValid() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<129>() * ::capnp::ELEMENTS);
}

inline bool StarPilotCarControl::Navigation::Builder::getControlValid() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<129>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarControl::Navigation::Builder::setControlValid(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<129>() * ::capnp::ELEMENTS, value);
}

inline  ::uint16_t StarPilotCarControl::Navigation::Reader::getVersion() const {
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<9>() * ::capnp::ELEMENTS);
}

inline  ::uint16_t StarPilotCarControl::Navigation::Builder::getVersion() {
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<9>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarControl::Navigation::Builder::setVersion( ::uint16_t value) {
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<9>() * ::capnp::ELEMENTS, value);
}

inline double StarPilotCarControl::Navigation::Coordinate::Reader::getLatitude() const {
  return _reader.getDataField<double>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline double StarPilotCarControl::Navigation::Coordinate::Builder::getLatitude() {
  return _builder.getDataField<double>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarControl::Navigation::Coordinate::Builder::setLatitude(double value) {
  _builder.setDataField<double>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline double StarPilotCarControl::Navigation::Coordinate::Reader::getLongitude() const {
  return _reader.getDataField<double>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline double StarPilotCarControl::Navigation::Coordinate::Builder::getLongitude() {
  return _builder.getDataField<double>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarControl::Navigation::Coordinate::Builder::setLongitude(double value) {
  _builder.setDataField<double>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotCarControl::Navigation::Instruction::Reader::hasText() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotCarControl::Navigation::Instruction::Builder::hasText() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader StarPilotCarControl::Navigation::Instruction::Reader::getText() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder StarPilotCarControl::Navigation::Instruction::Builder::getText() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void StarPilotCarControl::Navigation::Instruction::Builder::setText( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder StarPilotCarControl::Navigation::Instruction::Builder::initText(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void StarPilotCarControl::Navigation::Instruction::Builder::adoptText(
    ::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> StarPilotCarControl::Navigation::Instruction::Builder::disownText() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline bool StarPilotCarControl::Navigation::Instruction::Reader::hasManeuverType() const {
  return !_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotCarControl::Navigation::Instruction::Builder::hasManeuverType() {
  return !_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader StarPilotCarControl::Navigation::Instruction::Reader::getManeuverType() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder StarPilotCarControl::Navigation::Instruction::Builder::getManeuverType() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline void StarPilotCarControl::Navigation::Instruction::Builder::setManeuverType( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder StarPilotCarControl::Navigation::Instruction::Builder::initManeuverType(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), size);
}
inline void StarPilotCarControl::Navigation::Instruction::Builder::adoptManeuverType(
    ::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> StarPilotCarControl::Navigation::Instruction::Builder::disownManeuverType() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}

inline bool StarPilotCarControl::Navigation::Instruction::Reader::hasManeuverModifier() const {
  return !_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotCarControl::Navigation::Instruction::Builder::hasManeuverModifier() {
  return !_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader StarPilotCarControl::Navigation::Instruction::Reader::getManeuverModifier() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder StarPilotCarControl::Navigation::Instruction::Builder::getManeuverModifier() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline void StarPilotCarControl::Navigation::Instruction::Builder::setManeuverModifier( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder StarPilotCarControl::Navigation::Instruction::Builder::initManeuverModifier(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), size);
}
inline void StarPilotCarControl::Navigation::Instruction::Builder::adoptManeuverModifier(
    ::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> StarPilotCarControl::Navigation::Instruction::Builder::disownManeuverModifier() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}

inline float StarPilotCarControl::Navigation::Instruction::Reader::getDistanceMeters() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline float StarPilotCarControl::Navigation::Instruction::Builder::getDistanceMeters() {
  return _builder.getDataField<float>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarControl::Navigation::Instruction::Builder::setDistanceMeters(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline float StarPilotCarControl::Navigation::Instruction::Reader::getRemainingDistanceMeters() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline float StarPilotCarControl::Navigation::Instruction::Builder::getRemainingDistanceMeters() {
  return _builder.getDataField<float>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarControl::Navigation::Instruction::Builder::setRemainingDistanceMeters(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline float StarPilotCarControl::Navigation::Instruction::Reader::getRemainingDurationSeconds() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline float StarPilotCarControl::Navigation::Instruction::Builder::getRemainingDurationSeconds() {
  return _builder.getDataField<float>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarControl::Navigation::Instruction::Builder::setRemainingDurationSeconds(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline  ::uint16_t StarPilotCarControl::PreapRadarStartup::Reader::getVersion() const {
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline  ::uint16_t StarPilotCarControl::PreapRadarStartup::Builder::getVersion() {
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarControl::PreapRadarStartup::Builder::setVersion( ::uint16_t value) {
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline  ::uint16_t StarPilotCarControl::PreapRadarStartup::Reader::getKind() const {
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline  ::uint16_t StarPilotCarControl::PreapRadarStartup::Builder::getKind() {
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarControl::PreapRadarStartup::Builder::setKind( ::uint16_t value) {
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotCarControl::PreapRadarStartup::Reader::hasCarParamsSha256() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotCarControl::PreapRadarStartup::Builder::hasCarParamsSha256() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Data::Reader StarPilotCarControl::PreapRadarStartup::Reader::getCarParamsSha256() const {
  return ::capnp::_::PointerHelpers< ::capnp::Data>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::capnp::Data::Builder StarPilotCarControl::PreapRadarStartup::Builder::getCarParamsSha256() {
  return ::capnp::_::PointerHelpers< ::capnp::Data>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void StarPilotCarControl::PreapRadarStartup::Builder::setCarParamsSha256( ::capnp::Data::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Data>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Data::Builder StarPilotCarControl::PreapRadarStartup::Builder::initCarParamsSha256(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Data>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void StarPilotCarControl::PreapRadarStartup::Builder::adoptCarParamsSha256(
    ::capnp::Orphan< ::capnp::Data>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Data>::adopt(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Data> StarPilotCarControl::PreapRadarStartup::Builder::disownCarParamsSha256() {
  return ::capnp::_::PointerHelpers< ::capnp::Data>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline  ::uint16_t StarPilotCarControl::PreapRadarStartup::Reader::getSafetyModel() const {
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline  ::uint16_t StarPilotCarControl::PreapRadarStartup::Builder::getSafetyModel() {
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarControl::PreapRadarStartup::Builder::setSafetyModel( ::uint16_t value) {
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline  ::uint16_t StarPilotCarControl::PreapRadarStartup::Reader::getSafetyParam() const {
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}

inline  ::uint16_t StarPilotCarControl::PreapRadarStartup::Builder::getSafetyParam() {
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarControl::PreapRadarStartup::Builder::setSafetyParam( ::uint16_t value) {
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS, value);
}

inline float StarPilotCarControl::PreapRadarStartup::Reader::getLateralOffset() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline float StarPilotCarControl::PreapRadarStartup::Builder::getLateralOffset() {
  return _builder.getDataField<float>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarControl::PreapRadarStartup::Builder::setLateralOffset(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline  ::uint16_t StarPilotCarControl::PreapPedalStartup::Reader::getVersion() const {
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline  ::uint16_t StarPilotCarControl::PreapPedalStartup::Builder::getVersion() {
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarControl::PreapPedalStartup::Builder::setVersion( ::uint16_t value) {
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline  ::uint16_t StarPilotCarControl::PreapPedalStartup::Reader::getKind() const {
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline  ::uint16_t StarPilotCarControl::PreapPedalStartup::Builder::getKind() {
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarControl::PreapPedalStartup::Builder::setKind( ::uint16_t value) {
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotCarControl::PreapPedalStartup::Reader::hasCarParamsSha256() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotCarControl::PreapPedalStartup::Builder::hasCarParamsSha256() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Data::Reader StarPilotCarControl::PreapPedalStartup::Reader::getCarParamsSha256() const {
  return ::capnp::_::PointerHelpers< ::capnp::Data>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::capnp::Data::Builder StarPilotCarControl::PreapPedalStartup::Builder::getCarParamsSha256() {
  return ::capnp::_::PointerHelpers< ::capnp::Data>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void StarPilotCarControl::PreapPedalStartup::Builder::setCarParamsSha256( ::capnp::Data::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Data>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Data::Builder StarPilotCarControl::PreapPedalStartup::Builder::initCarParamsSha256(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Data>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void StarPilotCarControl::PreapPedalStartup::Builder::adoptCarParamsSha256(
    ::capnp::Orphan< ::capnp::Data>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Data>::adopt(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Data> StarPilotCarControl::PreapPedalStartup::Builder::disownCarParamsSha256() {
  return ::capnp::_::PointerHelpers< ::capnp::Data>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline  ::uint16_t StarPilotCarControl::PreapPedalStartup::Reader::getSafetyModel() const {
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline  ::uint16_t StarPilotCarControl::PreapPedalStartup::Builder::getSafetyModel() {
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarControl::PreapPedalStartup::Builder::setSafetyModel( ::uint16_t value) {
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline  ::uint16_t StarPilotCarControl::PreapPedalStartup::Reader::getSafetyParam() const {
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}

inline  ::uint16_t StarPilotCarControl::PreapPedalStartup::Builder::getSafetyParam() {
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarControl::PreapPedalStartup::Builder::setSafetyParam( ::uint16_t value) {
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS, value);
}

inline float StarPilotCarControl::PreapPedalStartup::Reader::getFactor() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline float StarPilotCarControl::PreapPedalStartup::Builder::getFactor() {
  return _builder.getDataField<float>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarControl::PreapPedalStartup::Builder::setFactor(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline float StarPilotCarControl::PreapPedalStartup::Reader::getZero() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}

inline float StarPilotCarControl::PreapPedalStartup::Builder::getZero() {
  return _builder.getDataField<float>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarControl::PreapPedalStartup::Builder::setZero(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS, value);
}

inline  ::uint16_t StarPilotCarControl::PreapPedalStartup::Reader::getPedalBus() const {
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<8>() * ::capnp::ELEMENTS);
}

inline  ::uint16_t StarPilotCarControl::PreapPedalStartup::Builder::getPedalBus() {
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<8>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarControl::PreapPedalStartup::Builder::setPedalBus( ::uint16_t value) {
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<8>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t StarPilotCarControl::PreapPedalStartup::Reader::getSourceMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t StarPilotCarControl::PreapPedalStartup::Builder::getSourceMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarControl::PreapPedalStartup::Builder::setSourceMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS, value);
}

inline  ::int16_t StarPilotCarParams::Reader::getAlternativeExperience() const {
  return _reader.getDataField< ::int16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline  ::int16_t StarPilotCarParams::Builder::getAlternativeExperience() {
  return _builder.getDataField< ::int16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarParams::Builder::setAlternativeExperience( ::int16_t value) {
  _builder.setDataField< ::int16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotCarParams::Reader::getCanUsePedal() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS);
}

inline bool StarPilotCarParams::Builder::getCanUsePedal() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarParams::Builder::setCanUsePedal(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotCarParams::Reader::getCanUseSDSU() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<17>() * ::capnp::ELEMENTS);
}

inline bool StarPilotCarParams::Builder::getCanUseSDSU() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<17>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarParams::Builder::setCanUseSDSU(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<17>() * ::capnp::ELEMENTS, value);
}

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

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

inline bool StarPilotCarParams::Reader::getIsHDA2() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<18>() * ::capnp::ELEMENTS);
}

inline bool StarPilotCarParams::Builder::getIsHDA2() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<18>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarParams::Builder::setIsHDA2(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<18>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotCarParams::Reader::getOpenpilotLongitudinalControlDisabled() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<19>() * ::capnp::ELEMENTS);
}

inline bool StarPilotCarParams::Builder::getOpenpilotLongitudinalControlDisabled() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<19>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarParams::Builder::setOpenpilotLongitudinalControlDisabled(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<19>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotCarParams::Reader::hasSafetyConfigs() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotCarParams::Builder::hasSafetyConfigs() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::List< ::cereal::StarPilotCarParams::SafetyConfig,  ::capnp::Kind::STRUCT>::Reader StarPilotCarParams::Reader::getSafetyConfigs() const {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::StarPilotCarParams::SafetyConfig,  ::capnp::Kind::STRUCT>>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::capnp::List< ::cereal::StarPilotCarParams::SafetyConfig,  ::capnp::Kind::STRUCT>::Builder StarPilotCarParams::Builder::getSafetyConfigs() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::StarPilotCarParams::SafetyConfig,  ::capnp::Kind::STRUCT>>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void StarPilotCarParams::Builder::setSafetyConfigs( ::capnp::List< ::cereal::StarPilotCarParams::SafetyConfig,  ::capnp::Kind::STRUCT>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::StarPilotCarParams::SafetyConfig,  ::capnp::Kind::STRUCT>>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::capnp::List< ::cereal::StarPilotCarParams::SafetyConfig,  ::capnp::Kind::STRUCT>::Builder StarPilotCarParams::Builder::initSafetyConfigs(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::StarPilotCarParams::SafetyConfig,  ::capnp::Kind::STRUCT>>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void StarPilotCarParams::Builder::adoptSafetyConfigs(
    ::capnp::Orphan< ::capnp::List< ::cereal::StarPilotCarParams::SafetyConfig,  ::capnp::Kind::STRUCT>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::StarPilotCarParams::SafetyConfig,  ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List< ::cereal::StarPilotCarParams::SafetyConfig,  ::capnp::Kind::STRUCT>> StarPilotCarParams::Builder::disownSafetyConfigs() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::StarPilotCarParams::SafetyConfig,  ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline bool StarPilotCarParams::Reader::getPcmCruiseSpeed() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<20>() * ::capnp::ELEMENTS, true);
}

inline bool StarPilotCarParams::Builder::getPcmCruiseSpeed() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<20>() * ::capnp::ELEMENTS, true);
}
inline void StarPilotCarParams::Builder::setPcmCruiseSpeed(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<20>() * ::capnp::ELEMENTS, value, true);
}

inline bool StarPilotCarParams::Reader::getRedneckCruiseAvailable() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<21>() * ::capnp::ELEMENTS);
}

inline bool StarPilotCarParams::Builder::getRedneckCruiseAvailable() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<21>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarParams::Builder::setRedneckCruiseAvailable(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<21>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotCarParams::Reader::hasLearning() const {
  return !_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotCarParams::Builder::hasLearning() {
  return !_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline  ::cereal::StarPilotCarParams::AutoSteeringLearning::Reader StarPilotCarParams::Reader::getLearning() const {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotCarParams::AutoSteeringLearning>::get(_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline  ::cereal::StarPilotCarParams::AutoSteeringLearning::Builder StarPilotCarParams::Builder::getLearning() {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotCarParams::AutoSteeringLearning>::get(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
#if !CAPNP_LITE
inline  ::cereal::StarPilotCarParams::AutoSteeringLearning::Pipeline StarPilotCarParams::Pipeline::getLearning() {
  return  ::cereal::StarPilotCarParams::AutoSteeringLearning::Pipeline(_typeless.getPointerField(1));
}
#endif  // !CAPNP_LITE
inline void StarPilotCarParams::Builder::setLearning( ::cereal::StarPilotCarParams::AutoSteeringLearning::Reader value) {
  ::capnp::_::PointerHelpers< ::cereal::StarPilotCarParams::AutoSteeringLearning>::set(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), value);
}
inline  ::cereal::StarPilotCarParams::AutoSteeringLearning::Builder StarPilotCarParams::Builder::initLearning() {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotCarParams::AutoSteeringLearning>::init(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline void StarPilotCarParams::Builder::adoptLearning(
    ::capnp::Orphan< ::cereal::StarPilotCarParams::AutoSteeringLearning>&& value) {
  ::capnp::_::PointerHelpers< ::cereal::StarPilotCarParams::AutoSteeringLearning>::adopt(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::cereal::StarPilotCarParams::AutoSteeringLearning> StarPilotCarParams::Builder::disownLearning() {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotCarParams::AutoSteeringLearning>::disown(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}

inline  ::uint16_t StarPilotCarParams::SafetyConfig::Reader::getSafetyParam() const {
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline  ::uint16_t StarPilotCarParams::SafetyConfig::Builder::getSafetyParam() {
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarParams::SafetyConfig::Builder::setSafetyParam( ::uint16_t value) {
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline  ::uint16_t StarPilotCarParams::AutoSteeringLearning::Reader::getVersion() const {
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline  ::uint16_t StarPilotCarParams::AutoSteeringLearning::Builder::getVersion() {
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarParams::AutoSteeringLearning::Builder::setVersion( ::uint16_t value) {
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline  ::cereal::StarPilotCarParams::AutoSteeringLearning::Status StarPilotCarParams::AutoSteeringLearning::Reader::getStatus() const {
  return _reader.getDataField< ::cereal::StarPilotCarParams::AutoSteeringLearning::Status>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline  ::cereal::StarPilotCarParams::AutoSteeringLearning::Status StarPilotCarParams::AutoSteeringLearning::Builder::getStatus() {
  return _builder.getDataField< ::cereal::StarPilotCarParams::AutoSteeringLearning::Status>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarParams::AutoSteeringLearning::Builder::setStatus( ::cereal::StarPilotCarParams::AutoSteeringLearning::Status value) {
  _builder.setDataField< ::cereal::StarPilotCarParams::AutoSteeringLearning::Status>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotCarParams::AutoSteeringLearning::Reader::hasReason() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotCarParams::AutoSteeringLearning::Builder::hasReason() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader StarPilotCarParams::AutoSteeringLearning::Reader::getReason() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder StarPilotCarParams::AutoSteeringLearning::Builder::getReason() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void StarPilotCarParams::AutoSteeringLearning::Builder::setReason( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder StarPilotCarParams::AutoSteeringLearning::Builder::initReason(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void StarPilotCarParams::AutoSteeringLearning::Builder::adoptReason(
    ::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> StarPilotCarParams::AutoSteeringLearning::Builder::disownReason() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline bool StarPilotCarParams::AutoSteeringLearning::Reader::hasIdentity() const {
  return !_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotCarParams::AutoSteeringLearning::Builder::hasIdentity() {
  return !_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline  ::cereal::StarPilotCarParams::AutoSteeringLearning::Identity::Reader StarPilotCarParams::AutoSteeringLearning::Reader::getIdentity() const {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotCarParams::AutoSteeringLearning::Identity>::get(_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline  ::cereal::StarPilotCarParams::AutoSteeringLearning::Identity::Builder StarPilotCarParams::AutoSteeringLearning::Builder::getIdentity() {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotCarParams::AutoSteeringLearning::Identity>::get(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
#if !CAPNP_LITE
inline  ::cereal::StarPilotCarParams::AutoSteeringLearning::Identity::Pipeline StarPilotCarParams::AutoSteeringLearning::Pipeline::getIdentity() {
  return  ::cereal::StarPilotCarParams::AutoSteeringLearning::Identity::Pipeline(_typeless.getPointerField(1));
}
#endif  // !CAPNP_LITE
inline void StarPilotCarParams::AutoSteeringLearning::Builder::setIdentity( ::cereal::StarPilotCarParams::AutoSteeringLearning::Identity::Reader value) {
  ::capnp::_::PointerHelpers< ::cereal::StarPilotCarParams::AutoSteeringLearning::Identity>::set(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), value);
}
inline  ::cereal::StarPilotCarParams::AutoSteeringLearning::Identity::Builder StarPilotCarParams::AutoSteeringLearning::Builder::initIdentity() {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotCarParams::AutoSteeringLearning::Identity>::init(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline void StarPilotCarParams::AutoSteeringLearning::Builder::adoptIdentity(
    ::capnp::Orphan< ::cereal::StarPilotCarParams::AutoSteeringLearning::Identity>&& value) {
  ::capnp::_::PointerHelpers< ::cereal::StarPilotCarParams::AutoSteeringLearning::Identity>::adopt(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::cereal::StarPilotCarParams::AutoSteeringLearning::Identity> StarPilotCarParams::AutoSteeringLearning::Builder::disownIdentity() {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotCarParams::AutoSteeringLearning::Identity>::disown(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}

inline bool StarPilotCarParams::AutoSteeringLearning::Reader::hasSession() const {
  return !_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotCarParams::AutoSteeringLearning::Builder::hasSession() {
  return !_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader StarPilotCarParams::AutoSteeringLearning::Reader::getSession() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder StarPilotCarParams::AutoSteeringLearning::Builder::getSession() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline void StarPilotCarParams::AutoSteeringLearning::Builder::setSession( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder StarPilotCarParams::AutoSteeringLearning::Builder::initSession(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), size);
}
inline void StarPilotCarParams::AutoSteeringLearning::Builder::adoptSession(
    ::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> StarPilotCarParams::AutoSteeringLearning::Builder::disownSession() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}

inline  ::uint64_t StarPilotCarParams::AutoSteeringLearning::Reader::getSequence() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t StarPilotCarParams::AutoSteeringLearning::Builder::getSequence() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarParams::AutoSteeringLearning::Builder::setSequence( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t StarPilotCarParams::AutoSteeringLearning::Reader::getObservedMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t StarPilotCarParams::AutoSteeringLearning::Builder::getObservedMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarParams::AutoSteeringLearning::Builder::setObservedMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t StarPilotCarParams::AutoSteeringLearning::Reader::getValidUntilMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t StarPilotCarParams::AutoSteeringLearning::Builder::getValidUntilMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarParams::AutoSteeringLearning::Builder::setValidUntilMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t StarPilotCarParams::AutoSteeringLearning::Reader::getSourceWindowStartMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t StarPilotCarParams::AutoSteeringLearning::Builder::getSourceWindowStartMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarParams::AutoSteeringLearning::Builder::setSourceWindowStartMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t StarPilotCarParams::AutoSteeringLearning::Reader::getSourceWindowEndMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t StarPilotCarParams::AutoSteeringLearning::Builder::getSourceWindowEndMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarParams::AutoSteeringLearning::Builder::setSourceWindowEndMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS, value);
}

inline  ::cereal::StarPilotCarParams::AutoSteeringLearning::Family StarPilotCarParams::AutoSteeringLearning::Reader::getFamily() const {
  return _reader.getDataField< ::cereal::StarPilotCarParams::AutoSteeringLearning::Family>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline  ::cereal::StarPilotCarParams::AutoSteeringLearning::Family StarPilotCarParams::AutoSteeringLearning::Builder::getFamily() {
  return _builder.getDataField< ::cereal::StarPilotCarParams::AutoSteeringLearning::Family>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarParams::AutoSteeringLearning::Builder::setFamily( ::cereal::StarPilotCarParams::AutoSteeringLearning::Family value) {
  _builder.setDataField< ::cereal::StarPilotCarParams::AutoSteeringLearning::Family>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline double StarPilotCarParams::AutoSteeringLearning::Reader::getLatAccelFactor() const {
  return _reader.getDataField<double>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS);
}

inline double StarPilotCarParams::AutoSteeringLearning::Builder::getLatAccelFactor() {
  return _builder.getDataField<double>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarParams::AutoSteeringLearning::Builder::setLatAccelFactor(double value) {
  _builder.setDataField<double>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotCarParams::AutoSteeringLearning::Reader::hasAcceptancePolicyId() const {
  return !_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotCarParams::AutoSteeringLearning::Builder::hasAcceptancePolicyId() {
  return !_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader StarPilotCarParams::AutoSteeringLearning::Reader::getAcceptancePolicyId() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder StarPilotCarParams::AutoSteeringLearning::Builder::getAcceptancePolicyId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline void StarPilotCarParams::AutoSteeringLearning::Builder::setAcceptancePolicyId( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder StarPilotCarParams::AutoSteeringLearning::Builder::initAcceptancePolicyId(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), size);
}
inline void StarPilotCarParams::AutoSteeringLearning::Builder::adoptAcceptancePolicyId(
    ::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> StarPilotCarParams::AutoSteeringLearning::Builder::disownAcceptancePolicyId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}

inline  ::uint32_t StarPilotCarParams::AutoSteeringLearning::Reader::getTrainWindows() const {
  return _reader.getDataField< ::uint32_t>(
      ::capnp::bounded<14>() * ::capnp::ELEMENTS);
}

inline  ::uint32_t StarPilotCarParams::AutoSteeringLearning::Builder::getTrainWindows() {
  return _builder.getDataField< ::uint32_t>(
      ::capnp::bounded<14>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarParams::AutoSteeringLearning::Builder::setTrainWindows( ::uint32_t value) {
  _builder.setDataField< ::uint32_t>(
      ::capnp::bounded<14>() * ::capnp::ELEMENTS, value);
}

inline  ::uint32_t StarPilotCarParams::AutoSteeringLearning::Reader::getHeldoutWindows() const {
  return _reader.getDataField< ::uint32_t>(
      ::capnp::bounded<15>() * ::capnp::ELEMENTS);
}

inline  ::uint32_t StarPilotCarParams::AutoSteeringLearning::Builder::getHeldoutWindows() {
  return _builder.getDataField< ::uint32_t>(
      ::capnp::bounded<15>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarParams::AutoSteeringLearning::Builder::setHeldoutWindows( ::uint32_t value) {
  _builder.setDataField< ::uint32_t>(
      ::capnp::bounded<15>() * ::capnp::ELEMENTS, value);
}

inline double StarPilotCarParams::AutoSteeringLearning::Reader::getTrainBaselineLoss() const {
  return _reader.getDataField<double>(
      ::capnp::bounded<8>() * ::capnp::ELEMENTS);
}

inline double StarPilotCarParams::AutoSteeringLearning::Builder::getTrainBaselineLoss() {
  return _builder.getDataField<double>(
      ::capnp::bounded<8>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarParams::AutoSteeringLearning::Builder::setTrainBaselineLoss(double value) {
  _builder.setDataField<double>(
      ::capnp::bounded<8>() * ::capnp::ELEMENTS, value);
}

inline double StarPilotCarParams::AutoSteeringLearning::Reader::getTrainCandidateLoss() const {
  return _reader.getDataField<double>(
      ::capnp::bounded<9>() * ::capnp::ELEMENTS);
}

inline double StarPilotCarParams::AutoSteeringLearning::Builder::getTrainCandidateLoss() {
  return _builder.getDataField<double>(
      ::capnp::bounded<9>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarParams::AutoSteeringLearning::Builder::setTrainCandidateLoss(double value) {
  _builder.setDataField<double>(
      ::capnp::bounded<9>() * ::capnp::ELEMENTS, value);
}

inline double StarPilotCarParams::AutoSteeringLearning::Reader::getHeldoutBaselineLoss() const {
  return _reader.getDataField<double>(
      ::capnp::bounded<10>() * ::capnp::ELEMENTS);
}

inline double StarPilotCarParams::AutoSteeringLearning::Builder::getHeldoutBaselineLoss() {
  return _builder.getDataField<double>(
      ::capnp::bounded<10>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarParams::AutoSteeringLearning::Builder::setHeldoutBaselineLoss(double value) {
  _builder.setDataField<double>(
      ::capnp::bounded<10>() * ::capnp::ELEMENTS, value);
}

inline double StarPilotCarParams::AutoSteeringLearning::Reader::getHeldoutCandidateLoss() const {
  return _reader.getDataField<double>(
      ::capnp::bounded<11>() * ::capnp::ELEMENTS);
}

inline double StarPilotCarParams::AutoSteeringLearning::Builder::getHeldoutCandidateLoss() {
  return _builder.getDataField<double>(
      ::capnp::bounded<11>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarParams::AutoSteeringLearning::Builder::setHeldoutCandidateLoss(double value) {
  _builder.setDataField<double>(
      ::capnp::bounded<11>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotCarParams::AutoSteeringLearning::Reader::hasRuntimeProfile() const {
  return !_reader.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotCarParams::AutoSteeringLearning::Builder::hasRuntimeProfile() {
  return !_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS).isNull();
}
inline  ::cereal::AutomaticRuntimeProfile::Reader StarPilotCarParams::AutoSteeringLearning::Reader::getRuntimeProfile() const {
  return ::capnp::_::PointerHelpers< ::cereal::AutomaticRuntimeProfile>::get(_reader.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}
inline  ::cereal::AutomaticRuntimeProfile::Builder StarPilotCarParams::AutoSteeringLearning::Builder::getRuntimeProfile() {
  return ::capnp::_::PointerHelpers< ::cereal::AutomaticRuntimeProfile>::get(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}
#if !CAPNP_LITE
inline  ::cereal::AutomaticRuntimeProfile::Pipeline StarPilotCarParams::AutoSteeringLearning::Pipeline::getRuntimeProfile() {
  return  ::cereal::AutomaticRuntimeProfile::Pipeline(_typeless.getPointerField(4));
}
#endif  // !CAPNP_LITE
inline void StarPilotCarParams::AutoSteeringLearning::Builder::setRuntimeProfile( ::cereal::AutomaticRuntimeProfile::Reader value) {
  ::capnp::_::PointerHelpers< ::cereal::AutomaticRuntimeProfile>::set(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), value);
}
inline  ::cereal::AutomaticRuntimeProfile::Builder StarPilotCarParams::AutoSteeringLearning::Builder::initRuntimeProfile() {
  return ::capnp::_::PointerHelpers< ::cereal::AutomaticRuntimeProfile>::init(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}
inline void StarPilotCarParams::AutoSteeringLearning::Builder::adoptRuntimeProfile(
    ::capnp::Orphan< ::cereal::AutomaticRuntimeProfile>&& value) {
  ::capnp::_::PointerHelpers< ::cereal::AutomaticRuntimeProfile>::adopt(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::cereal::AutomaticRuntimeProfile> StarPilotCarParams::AutoSteeringLearning::Builder::disownRuntimeProfile() {
  return ::capnp::_::PointerHelpers< ::cereal::AutomaticRuntimeProfile>::disown(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}

inline bool StarPilotCarParams::AutoSteeringLearning::Reader::hasSourceReceipt() const {
  return !_reader.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotCarParams::AutoSteeringLearning::Builder::hasSourceReceipt() {
  return !_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS).isNull();
}
inline  ::cereal::AutomaticLearningSourceReceipt::Reader StarPilotCarParams::AutoSteeringLearning::Reader::getSourceReceipt() const {
  return ::capnp::_::PointerHelpers< ::cereal::AutomaticLearningSourceReceipt>::get(_reader.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS));
}
inline  ::cereal::AutomaticLearningSourceReceipt::Builder StarPilotCarParams::AutoSteeringLearning::Builder::getSourceReceipt() {
  return ::capnp::_::PointerHelpers< ::cereal::AutomaticLearningSourceReceipt>::get(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS));
}
#if !CAPNP_LITE
inline  ::cereal::AutomaticLearningSourceReceipt::Pipeline StarPilotCarParams::AutoSteeringLearning::Pipeline::getSourceReceipt() {
  return  ::cereal::AutomaticLearningSourceReceipt::Pipeline(_typeless.getPointerField(5));
}
#endif  // !CAPNP_LITE
inline void StarPilotCarParams::AutoSteeringLearning::Builder::setSourceReceipt( ::cereal::AutomaticLearningSourceReceipt::Reader value) {
  ::capnp::_::PointerHelpers< ::cereal::AutomaticLearningSourceReceipt>::set(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS), value);
}
inline  ::cereal::AutomaticLearningSourceReceipt::Builder StarPilotCarParams::AutoSteeringLearning::Builder::initSourceReceipt() {
  return ::capnp::_::PointerHelpers< ::cereal::AutomaticLearningSourceReceipt>::init(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS));
}
inline void StarPilotCarParams::AutoSteeringLearning::Builder::adoptSourceReceipt(
    ::capnp::Orphan< ::cereal::AutomaticLearningSourceReceipt>&& value) {
  ::capnp::_::PointerHelpers< ::cereal::AutomaticLearningSourceReceipt>::adopt(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::cereal::AutomaticLearningSourceReceipt> StarPilotCarParams::AutoSteeringLearning::Builder::disownSourceReceipt() {
  return ::capnp::_::PointerHelpers< ::cereal::AutomaticLearningSourceReceipt>::disown(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS));
}

inline bool StarPilotCarParams::AutoSteeringLearning::Reader::hasCentreApplicationWitness() const {
  return !_reader.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotCarParams::AutoSteeringLearning::Builder::hasCentreApplicationWitness() {
  return !_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS).isNull();
}
inline  ::cereal::CentreApplicationWitness::Reader StarPilotCarParams::AutoSteeringLearning::Reader::getCentreApplicationWitness() const {
  return ::capnp::_::PointerHelpers< ::cereal::CentreApplicationWitness>::get(_reader.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS));
}
inline  ::cereal::CentreApplicationWitness::Builder StarPilotCarParams::AutoSteeringLearning::Builder::getCentreApplicationWitness() {
  return ::capnp::_::PointerHelpers< ::cereal::CentreApplicationWitness>::get(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS));
}
#if !CAPNP_LITE
inline  ::cereal::CentreApplicationWitness::Pipeline StarPilotCarParams::AutoSteeringLearning::Pipeline::getCentreApplicationWitness() {
  return  ::cereal::CentreApplicationWitness::Pipeline(_typeless.getPointerField(6));
}
#endif  // !CAPNP_LITE
inline void StarPilotCarParams::AutoSteeringLearning::Builder::setCentreApplicationWitness( ::cereal::CentreApplicationWitness::Reader value) {
  ::capnp::_::PointerHelpers< ::cereal::CentreApplicationWitness>::set(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS), value);
}
inline  ::cereal::CentreApplicationWitness::Builder StarPilotCarParams::AutoSteeringLearning::Builder::initCentreApplicationWitness() {
  return ::capnp::_::PointerHelpers< ::cereal::CentreApplicationWitness>::init(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS));
}
inline void StarPilotCarParams::AutoSteeringLearning::Builder::adoptCentreApplicationWitness(
    ::capnp::Orphan< ::cereal::CentreApplicationWitness>&& value) {
  ::capnp::_::PointerHelpers< ::cereal::CentreApplicationWitness>::adopt(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::cereal::CentreApplicationWitness> StarPilotCarParams::AutoSteeringLearning::Builder::disownCentreApplicationWitness() {
  return ::capnp::_::PointerHelpers< ::cereal::CentreApplicationWitness>::disown(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS));
}

inline bool StarPilotCarParams::AutoSteeringLearning::Identity::Reader::hasVehicle() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotCarParams::AutoSteeringLearning::Identity::Builder::hasVehicle() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader StarPilotCarParams::AutoSteeringLearning::Identity::Reader::getVehicle() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder StarPilotCarParams::AutoSteeringLearning::Identity::Builder::getVehicle() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void StarPilotCarParams::AutoSteeringLearning::Identity::Builder::setVehicle( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder StarPilotCarParams::AutoSteeringLearning::Identity::Builder::initVehicle(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void StarPilotCarParams::AutoSteeringLearning::Identity::Builder::adoptVehicle(
    ::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> StarPilotCarParams::AutoSteeringLearning::Identity::Builder::disownVehicle() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline bool StarPilotCarParams::AutoSteeringLearning::Identity::Reader::hasBrand() const {
  return !_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotCarParams::AutoSteeringLearning::Identity::Builder::hasBrand() {
  return !_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader StarPilotCarParams::AutoSteeringLearning::Identity::Reader::getBrand() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder StarPilotCarParams::AutoSteeringLearning::Identity::Builder::getBrand() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline void StarPilotCarParams::AutoSteeringLearning::Identity::Builder::setBrand( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder StarPilotCarParams::AutoSteeringLearning::Identity::Builder::initBrand(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), size);
}
inline void StarPilotCarParams::AutoSteeringLearning::Identity::Builder::adoptBrand(
    ::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> StarPilotCarParams::AutoSteeringLearning::Identity::Builder::disownBrand() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}

inline bool StarPilotCarParams::AutoSteeringLearning::Identity::Reader::hasController() const {
  return !_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotCarParams::AutoSteeringLearning::Identity::Builder::hasController() {
  return !_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader StarPilotCarParams::AutoSteeringLearning::Identity::Reader::getController() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder StarPilotCarParams::AutoSteeringLearning::Identity::Builder::getController() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline void StarPilotCarParams::AutoSteeringLearning::Identity::Builder::setController( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder StarPilotCarParams::AutoSteeringLearning::Identity::Builder::initController(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), size);
}
inline void StarPilotCarParams::AutoSteeringLearning::Identity::Builder::adoptController(
    ::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> StarPilotCarParams::AutoSteeringLearning::Identity::Builder::disownController() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}

inline bool StarPilotCarParams::AutoSteeringLearning::Identity::Reader::hasPolicy() const {
  return !_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotCarParams::AutoSteeringLearning::Identity::Builder::hasPolicy() {
  return !_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader StarPilotCarParams::AutoSteeringLearning::Identity::Reader::getPolicy() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder StarPilotCarParams::AutoSteeringLearning::Identity::Builder::getPolicy() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline void StarPilotCarParams::AutoSteeringLearning::Identity::Builder::setPolicy( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder StarPilotCarParams::AutoSteeringLearning::Identity::Builder::initPolicy(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), size);
}
inline void StarPilotCarParams::AutoSteeringLearning::Identity::Builder::adoptPolicy(
    ::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> StarPilotCarParams::AutoSteeringLearning::Identity::Builder::disownPolicy() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}

inline bool StarPilotCarParams::AutoSteeringLearning::Identity::Reader::hasProfile() const {
  return !_reader.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotCarParams::AutoSteeringLearning::Identity::Builder::hasProfile() {
  return !_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader StarPilotCarParams::AutoSteeringLearning::Identity::Reader::getProfile() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder StarPilotCarParams::AutoSteeringLearning::Identity::Builder::getProfile() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}
inline void StarPilotCarParams::AutoSteeringLearning::Identity::Builder::setProfile( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder StarPilotCarParams::AutoSteeringLearning::Identity::Builder::initProfile(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), size);
}
inline void StarPilotCarParams::AutoSteeringLearning::Identity::Builder::adoptProfile(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> StarPilotCarParams::AutoSteeringLearning::Identity::Builder::disownProfile() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}

inline bool StarPilotCarParams::AutoSteeringLearning::Identity::Reader::hasConversionVersion() const {
  return !_reader.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotCarParams::AutoSteeringLearning::Identity::Builder::hasConversionVersion() {
  return !_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader StarPilotCarParams::AutoSteeringLearning::Identity::Reader::getConversionVersion() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder StarPilotCarParams::AutoSteeringLearning::Identity::Builder::getConversionVersion() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS));
}
inline void StarPilotCarParams::AutoSteeringLearning::Identity::Builder::setConversionVersion( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder StarPilotCarParams::AutoSteeringLearning::Identity::Builder::initConversionVersion(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS), size);
}
inline void StarPilotCarParams::AutoSteeringLearning::Identity::Builder::adoptConversionVersion(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> StarPilotCarParams::AutoSteeringLearning::Identity::Builder::disownConversionVersion() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS));
}

inline bool StarPilotCarParams::AutoSteeringLearning::Identity::Reader::hasFirmwareSha256() const {
  return !_reader.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotCarParams::AutoSteeringLearning::Identity::Builder::hasFirmwareSha256() {
  return !_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader StarPilotCarParams::AutoSteeringLearning::Identity::Reader::getFirmwareSha256() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder StarPilotCarParams::AutoSteeringLearning::Identity::Builder::getFirmwareSha256() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS));
}
inline void StarPilotCarParams::AutoSteeringLearning::Identity::Builder::setFirmwareSha256( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder StarPilotCarParams::AutoSteeringLearning::Identity::Builder::initFirmwareSha256(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS), size);
}
inline void StarPilotCarParams::AutoSteeringLearning::Identity::Builder::adoptFirmwareSha256(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> StarPilotCarParams::AutoSteeringLearning::Identity::Builder::disownFirmwareSha256() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS));
}

inline bool StarPilotCarParams::AutoSteeringLearning::Identity::Reader::hasBasis() const {
  return !_reader.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotCarParams::AutoSteeringLearning::Identity::Builder::hasBasis() {
  return !_builder.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Reader StarPilotCarParams::AutoSteeringLearning::Identity::Reader::getBasis() const {
  return ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS));
}
inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Builder StarPilotCarParams::AutoSteeringLearning::Identity::Builder::getBasis() {
  return ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS));
}
inline void StarPilotCarParams::AutoSteeringLearning::Identity::Builder::setBasis( ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS), value);
}
inline void StarPilotCarParams::AutoSteeringLearning::Identity::Builder::setBasis(::kj::ArrayPtr<const double> value) {
  ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS), value);
}
inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Builder StarPilotCarParams::AutoSteeringLearning::Identity::Builder::initBasis(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS), size);
}
inline void StarPilotCarParams::AutoSteeringLearning::Identity::Builder::adoptBasis(
    ::capnp::Orphan< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>> StarPilotCarParams::AutoSteeringLearning::Identity::Builder::disownBasis() {
  return ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS));
}

inline bool StarPilotCarParams::AutoSteeringLearning::Identity::Reader::hasBaselineSha256() const {
  return !_reader.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotCarParams::AutoSteeringLearning::Identity::Builder::hasBaselineSha256() {
  return !_builder.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader StarPilotCarParams::AutoSteeringLearning::Identity::Reader::getBaselineSha256() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder StarPilotCarParams::AutoSteeringLearning::Identity::Builder::getBaselineSha256() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS));
}
inline void StarPilotCarParams::AutoSteeringLearning::Identity::Builder::setBaselineSha256( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder StarPilotCarParams::AutoSteeringLearning::Identity::Builder::initBaselineSha256(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS), size);
}
inline void StarPilotCarParams::AutoSteeringLearning::Identity::Builder::adoptBaselineSha256(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> StarPilotCarParams::AutoSteeringLearning::Identity::Builder::disownBaselineSha256() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS));
}

inline bool StarPilotCarParams::AutoSteeringLearning::Identity::Reader::hasPreferenceSha256() const {
  return !_reader.getPointerField(
      ::capnp::bounded<9>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotCarParams::AutoSteeringLearning::Identity::Builder::hasPreferenceSha256() {
  return !_builder.getPointerField(
      ::capnp::bounded<9>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader StarPilotCarParams::AutoSteeringLearning::Identity::Reader::getPreferenceSha256() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<9>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder StarPilotCarParams::AutoSteeringLearning::Identity::Builder::getPreferenceSha256() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<9>() * ::capnp::POINTERS));
}
inline void StarPilotCarParams::AutoSteeringLearning::Identity::Builder::setPreferenceSha256( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<9>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder StarPilotCarParams::AutoSteeringLearning::Identity::Builder::initPreferenceSha256(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<9>() * ::capnp::POINTERS), size);
}
inline void StarPilotCarParams::AutoSteeringLearning::Identity::Builder::adoptPreferenceSha256(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<9>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> StarPilotCarParams::AutoSteeringLearning::Identity::Builder::disownPreferenceSha256() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<9>() * ::capnp::POINTERS));
}

inline bool StarPilotCarParams::AutoSteeringLearning::Identity::Reader::hasResetGeneration() const {
  return !_reader.getPointerField(
      ::capnp::bounded<10>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotCarParams::AutoSteeringLearning::Identity::Builder::hasResetGeneration() {
  return !_builder.getPointerField(
      ::capnp::bounded<10>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader StarPilotCarParams::AutoSteeringLearning::Identity::Reader::getResetGeneration() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<10>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder StarPilotCarParams::AutoSteeringLearning::Identity::Builder::getResetGeneration() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<10>() * ::capnp::POINTERS));
}
inline void StarPilotCarParams::AutoSteeringLearning::Identity::Builder::setResetGeneration( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<10>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder StarPilotCarParams::AutoSteeringLearning::Identity::Builder::initResetGeneration(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<10>() * ::capnp::POINTERS), size);
}
inline void StarPilotCarParams::AutoSteeringLearning::Identity::Builder::adoptResetGeneration(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<10>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> StarPilotCarParams::AutoSteeringLearning::Identity::Builder::disownResetGeneration() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<10>() * ::capnp::POINTERS));
}

inline bool StarPilotCarParams::AutoSteeringLearning::Identity::Reader::hasControllerRevision() const {
  return !_reader.getPointerField(
      ::capnp::bounded<11>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotCarParams::AutoSteeringLearning::Identity::Builder::hasControllerRevision() {
  return !_builder.getPointerField(
      ::capnp::bounded<11>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader StarPilotCarParams::AutoSteeringLearning::Identity::Reader::getControllerRevision() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<11>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder StarPilotCarParams::AutoSteeringLearning::Identity::Builder::getControllerRevision() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<11>() * ::capnp::POINTERS));
}
inline void StarPilotCarParams::AutoSteeringLearning::Identity::Builder::setControllerRevision( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<11>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder StarPilotCarParams::AutoSteeringLearning::Identity::Builder::initControllerRevision(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<11>() * ::capnp::POINTERS), size);
}
inline void StarPilotCarParams::AutoSteeringLearning::Identity::Builder::adoptControllerRevision(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<11>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> StarPilotCarParams::AutoSteeringLearning::Identity::Builder::disownControllerRevision() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<11>() * ::capnp::POINTERS));
}

inline bool StarPilotCarState::Reader::getAccelPressed() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline bool StarPilotCarState::Builder::getAccelPressed() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarState::Builder::setAccelPressed(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotCarState::Reader::getAlwaysOnLateralEnabled() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline bool StarPilotCarState::Builder::getAlwaysOnLateralEnabled() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarState::Builder::setAlwaysOnLateralEnabled(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotCarState::Reader::getBrakeLights() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline bool StarPilotCarState::Builder::getBrakeLights() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarState::Builder::setBrakeLights(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline float StarPilotCarState::Reader::getDashboardSpeedLimit() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline float StarPilotCarState::Builder::getDashboardSpeedLimit() {
  return _builder.getDataField<float>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarState::Builder::setDashboardSpeedLimit(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotCarState::Reader::getDecelPressed() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}

inline bool StarPilotCarState::Builder::getDecelPressed() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarState::Builder::setDecelPressed(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotCarState::Reader::getDistancePressed() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}

inline bool StarPilotCarState::Builder::getDistancePressed() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarState::Builder::setDistancePressed(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotCarState::Reader::getDistanceLongPressed() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}

inline bool StarPilotCarState::Builder::getDistanceLongPressed() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarState::Builder::setDistanceLongPressed(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotCarState::Reader::getDistanceVeryLongPressed() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS);
}

inline bool StarPilotCarState::Builder::getDistanceVeryLongPressed() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarState::Builder::setDistanceVeryLongPressed(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotCarState::Reader::getEcoGear() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<7>() * ::capnp::ELEMENTS);
}

inline bool StarPilotCarState::Builder::getEcoGear() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<7>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarState::Builder::setEcoGear(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<7>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotCarState::Reader::getForceCoast() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<8>() * ::capnp::ELEMENTS);
}

inline bool StarPilotCarState::Builder::getForceCoast() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<8>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarState::Builder::setForceCoast(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<8>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotCarState::Reader::getIsParked() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<9>() * ::capnp::ELEMENTS);
}

inline bool StarPilotCarState::Builder::getIsParked() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<9>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarState::Builder::setIsParked(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<9>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotCarState::Reader::getPauseLateral() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<10>() * ::capnp::ELEMENTS);
}

inline bool StarPilotCarState::Builder::getPauseLateral() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<10>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarState::Builder::setPauseLateral(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<10>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotCarState::Reader::getPauseLongitudinal() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<11>() * ::capnp::ELEMENTS);
}

inline bool StarPilotCarState::Builder::getPauseLongitudinal() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<11>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarState::Builder::setPauseLongitudinal(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<11>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotCarState::Reader::getSportGear() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<12>() * ::capnp::ELEMENTS);
}

inline bool StarPilotCarState::Builder::getSportGear() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<12>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarState::Builder::setSportGear(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<12>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotCarState::Reader::getTrafficModeEnabled() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<13>() * ::capnp::ELEMENTS);
}

inline bool StarPilotCarState::Builder::getTrafficModeEnabled() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<13>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarState::Builder::setTrafficModeEnabled(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<13>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotCarState::Reader::getGasStack() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<14>() * ::capnp::ELEMENTS);
}

inline bool StarPilotCarState::Builder::getGasStack() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<14>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarState::Builder::setGasStack(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<14>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotCarState::Reader::getModePressed() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<15>() * ::capnp::ELEMENTS);
}

inline bool StarPilotCarState::Builder::getModePressed() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<15>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarState::Builder::setModePressed(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<15>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotCarState::Reader::getCustomPressed() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS);
}

inline bool StarPilotCarState::Builder::getCustomPressed() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarState::Builder::setCustomPressed(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotCarState::Reader::getAlwaysOnLateralAllowed() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<17>() * ::capnp::ELEMENTS);
}

inline bool StarPilotCarState::Builder::getAlwaysOnLateralAllowed() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<17>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarState::Builder::setAlwaysOnLateralAllowed(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<17>() * ::capnp::ELEMENTS, value);
}

inline  ::uint8_t StarPilotCarState::Reader::getDashboardStopSign() const {
  return _reader.getDataField< ::uint8_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}

inline  ::uint8_t StarPilotCarState::Builder::getDashboardStopSign() {
  return _builder.getDataField< ::uint8_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarState::Builder::setDashboardStopSign( ::uint8_t value) {
  _builder.setDataField< ::uint8_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotCarState::Reader::getCancelPressed() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<18>() * ::capnp::ELEMENTS);
}

inline bool StarPilotCarState::Builder::getCancelPressed() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<18>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarState::Builder::setCancelPressed(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<18>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotCarState::Reader::getCancelLongPressed() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<19>() * ::capnp::ELEMENTS);
}

inline bool StarPilotCarState::Builder::getCancelLongPressed() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<19>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarState::Builder::setCancelLongPressed(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<19>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotCarState::Reader::getCancelVeryLongPressed() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<20>() * ::capnp::ELEMENTS);
}

inline bool StarPilotCarState::Builder::getCancelVeryLongPressed() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<20>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarState::Builder::setCancelVeryLongPressed(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<20>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotCarState::Reader::getPedalMaxRegen() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<21>() * ::capnp::ELEMENTS);
}

inline bool StarPilotCarState::Builder::getPedalMaxRegen() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<21>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarState::Builder::setPedalMaxRegen(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<21>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotCarState::Reader::getPedalLongActive() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<22>() * ::capnp::ELEMENTS);
}

inline bool StarPilotCarState::Builder::getPedalLongActive() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<22>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarState::Builder::setPedalLongActive(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<22>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotCarState::Reader::getTeslaCCEngaged() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<23>() * ::capnp::ELEMENTS);
}

inline bool StarPilotCarState::Builder::getTeslaCCEngaged() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<23>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarState::Builder::setTeslaCCEngaged(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<23>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotCarState::Reader::getTeslaCCDisengaged() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<64>() * ::capnp::ELEMENTS);
}

inline bool StarPilotCarState::Builder::getTeslaCCDisengaged() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<64>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarState::Builder::setTeslaCCDisengaged(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<64>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotCarState::Reader::getTeslaCCNotArmed() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<65>() * ::capnp::ELEMENTS);
}

inline bool StarPilotCarState::Builder::getTeslaCCNotArmed() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<65>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarState::Builder::setTeslaCCNotArmed(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<65>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotCarState::Reader::getAccelHardCruise() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<66>() * ::capnp::ELEMENTS);
}

inline bool StarPilotCarState::Builder::getAccelHardCruise() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<66>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarState::Builder::setAccelHardCruise(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<66>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotCarState::Reader::getDecelHardCruise() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<67>() * ::capnp::ELEMENTS);
}

inline bool StarPilotCarState::Builder::getDecelHardCruise() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<67>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarState::Builder::setDecelHardCruise(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<67>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotCarState::Reader::getPulseAndGlide() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<68>() * ::capnp::ELEMENTS);
}

inline bool StarPilotCarState::Builder::getPulseAndGlide() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<68>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarState::Builder::setPulseAndGlide(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<68>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotCarState::Reader::hasGps() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotCarState::Builder::hasGps() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::cereal::StarPilotCarState::Gps::Reader StarPilotCarState::Reader::getGps() const {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotCarState::Gps>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::cereal::StarPilotCarState::Gps::Builder StarPilotCarState::Builder::getGps() {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotCarState::Gps>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
#if !CAPNP_LITE
inline  ::cereal::StarPilotCarState::Gps::Pipeline StarPilotCarState::Pipeline::getGps() {
  return  ::cereal::StarPilotCarState::Gps::Pipeline(_typeless.getPointerField(0));
}
#endif  // !CAPNP_LITE
inline void StarPilotCarState::Builder::setGps( ::cereal::StarPilotCarState::Gps::Reader value) {
  ::capnp::_::PointerHelpers< ::cereal::StarPilotCarState::Gps>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::cereal::StarPilotCarState::Gps::Builder StarPilotCarState::Builder::initGps() {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotCarState::Gps>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void StarPilotCarState::Builder::adoptGps(
    ::capnp::Orphan< ::cereal::StarPilotCarState::Gps>&& value) {
  ::capnp::_::PointerHelpers< ::cereal::StarPilotCarState::Gps>::adopt(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::cereal::StarPilotCarState::Gps> StarPilotCarState::Builder::disownGps() {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotCarState::Gps>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline bool StarPilotCarState::Reader::getLateralAuthorityUnavailable() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<69>() * ::capnp::ELEMENTS);
}

inline bool StarPilotCarState::Builder::getLateralAuthorityUnavailable() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<69>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarState::Builder::setLateralAuthorityUnavailable(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<69>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t StarPilotCarState::Reader::getSourceCarStateMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t StarPilotCarState::Builder::getSourceCarStateMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarState::Builder::setSourceCarStateMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotCarState::Reader::hasAppliedEvidence() const {
  return !_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotCarState::Builder::hasAppliedEvidence() {
  return !_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline  ::cereal::LearningAppliedEvidence::Reader StarPilotCarState::Reader::getAppliedEvidence() const {
  return ::capnp::_::PointerHelpers< ::cereal::LearningAppliedEvidence>::get(_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline  ::cereal::LearningAppliedEvidence::Builder StarPilotCarState::Builder::getAppliedEvidence() {
  return ::capnp::_::PointerHelpers< ::cereal::LearningAppliedEvidence>::get(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
#if !CAPNP_LITE
inline  ::cereal::LearningAppliedEvidence::Pipeline StarPilotCarState::Pipeline::getAppliedEvidence() {
  return  ::cereal::LearningAppliedEvidence::Pipeline(_typeless.getPointerField(1));
}
#endif  // !CAPNP_LITE
inline void StarPilotCarState::Builder::setAppliedEvidence( ::cereal::LearningAppliedEvidence::Reader value) {
  ::capnp::_::PointerHelpers< ::cereal::LearningAppliedEvidence>::set(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), value);
}
inline  ::cereal::LearningAppliedEvidence::Builder StarPilotCarState::Builder::initAppliedEvidence() {
  return ::capnp::_::PointerHelpers< ::cereal::LearningAppliedEvidence>::init(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline void StarPilotCarState::Builder::adoptAppliedEvidence(
    ::capnp::Orphan< ::cereal::LearningAppliedEvidence>&& value) {
  ::capnp::_::PointerHelpers< ::cereal::LearningAppliedEvidence>::adopt(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::cereal::LearningAppliedEvidence> StarPilotCarState::Builder::disownAppliedEvidence() {
  return ::capnp::_::PointerHelpers< ::cereal::LearningAppliedEvidence>::disown(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}

inline bool StarPilotCarState::Reader::hasFordLearningEvidence() const {
  return !_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotCarState::Builder::hasFordLearningEvidence() {
  return !_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline  ::cereal::FordLearningEvidence::Reader StarPilotCarState::Reader::getFordLearningEvidence() const {
  return ::capnp::_::PointerHelpers< ::cereal::FordLearningEvidence>::get(_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline  ::cereal::FordLearningEvidence::Builder StarPilotCarState::Builder::getFordLearningEvidence() {
  return ::capnp::_::PointerHelpers< ::cereal::FordLearningEvidence>::get(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
#if !CAPNP_LITE
inline  ::cereal::FordLearningEvidence::Pipeline StarPilotCarState::Pipeline::getFordLearningEvidence() {
  return  ::cereal::FordLearningEvidence::Pipeline(_typeless.getPointerField(2));
}
#endif  // !CAPNP_LITE
inline void StarPilotCarState::Builder::setFordLearningEvidence( ::cereal::FordLearningEvidence::Reader value) {
  ::capnp::_::PointerHelpers< ::cereal::FordLearningEvidence>::set(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), value);
}
inline  ::cereal::FordLearningEvidence::Builder StarPilotCarState::Builder::initFordLearningEvidence() {
  return ::capnp::_::PointerHelpers< ::cereal::FordLearningEvidence>::init(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline void StarPilotCarState::Builder::adoptFordLearningEvidence(
    ::capnp::Orphan< ::cereal::FordLearningEvidence>&& value) {
  ::capnp::_::PointerHelpers< ::cereal::FordLearningEvidence>::adopt(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::cereal::FordLearningEvidence> StarPilotCarState::Builder::disownFordLearningEvidence() {
  return ::capnp::_::PointerHelpers< ::cereal::FordLearningEvidence>::disown(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}

inline bool StarPilotCarState::Reader::hasLearningApplication() const {
  return !_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotCarState::Builder::hasLearningApplication() {
  return !_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline  ::cereal::LearningApplication::Reader StarPilotCarState::Reader::getLearningApplication() const {
  return ::capnp::_::PointerHelpers< ::cereal::LearningApplication>::get(_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline  ::cereal::LearningApplication::Builder StarPilotCarState::Builder::getLearningApplication() {
  return ::capnp::_::PointerHelpers< ::cereal::LearningApplication>::get(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
#if !CAPNP_LITE
inline  ::cereal::LearningApplication::Pipeline StarPilotCarState::Pipeline::getLearningApplication() {
  return  ::cereal::LearningApplication::Pipeline(_typeless.getPointerField(3));
}
#endif  // !CAPNP_LITE
inline void StarPilotCarState::Builder::setLearningApplication( ::cereal::LearningApplication::Reader value) {
  ::capnp::_::PointerHelpers< ::cereal::LearningApplication>::set(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), value);
}
inline  ::cereal::LearningApplication::Builder StarPilotCarState::Builder::initLearningApplication() {
  return ::capnp::_::PointerHelpers< ::cereal::LearningApplication>::init(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline void StarPilotCarState::Builder::adoptLearningApplication(
    ::capnp::Orphan< ::cereal::LearningApplication>&& value) {
  ::capnp::_::PointerHelpers< ::cereal::LearningApplication>::adopt(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::cereal::LearningApplication> StarPilotCarState::Builder::disownLearningApplication() {
  return ::capnp::_::PointerHelpers< ::cereal::LearningApplication>::disown(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}

inline bool StarPilotCarState::Reader::hasFeedbackPublication() const {
  return !_reader.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotCarState::Builder::hasFeedbackPublication() {
  return !_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS).isNull();
}
inline  ::cereal::StarPilotCarState::FeedbackPublication::Reader StarPilotCarState::Reader::getFeedbackPublication() const {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotCarState::FeedbackPublication>::get(_reader.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}
inline  ::cereal::StarPilotCarState::FeedbackPublication::Builder StarPilotCarState::Builder::getFeedbackPublication() {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotCarState::FeedbackPublication>::get(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}
#if !CAPNP_LITE
inline  ::cereal::StarPilotCarState::FeedbackPublication::Pipeline StarPilotCarState::Pipeline::getFeedbackPublication() {
  return  ::cereal::StarPilotCarState::FeedbackPublication::Pipeline(_typeless.getPointerField(4));
}
#endif  // !CAPNP_LITE
inline void StarPilotCarState::Builder::setFeedbackPublication( ::cereal::StarPilotCarState::FeedbackPublication::Reader value) {
  ::capnp::_::PointerHelpers< ::cereal::StarPilotCarState::FeedbackPublication>::set(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), value);
}
inline  ::cereal::StarPilotCarState::FeedbackPublication::Builder StarPilotCarState::Builder::initFeedbackPublication() {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotCarState::FeedbackPublication>::init(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}
inline void StarPilotCarState::Builder::adoptFeedbackPublication(
    ::capnp::Orphan< ::cereal::StarPilotCarState::FeedbackPublication>&& value) {
  ::capnp::_::PointerHelpers< ::cereal::StarPilotCarState::FeedbackPublication>::adopt(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::cereal::StarPilotCarState::FeedbackPublication> StarPilotCarState::Builder::disownFeedbackPublication() {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotCarState::FeedbackPublication>::disown(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}

inline  ::uint64_t StarPilotCarState::Gps::Reader::getSourceMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t StarPilotCarState::Gps::Builder::getSourceMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarState::Gps::Builder::setSourceMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline double StarPilotCarState::Gps::Reader::getLatitude() const {
  return _reader.getDataField<double>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline double StarPilotCarState::Gps::Builder::getLatitude() {
  return _builder.getDataField<double>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarState::Gps::Builder::setLatitude(double value) {
  _builder.setDataField<double>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline double StarPilotCarState::Gps::Reader::getLongitude() const {
  return _reader.getDataField<double>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline double StarPilotCarState::Gps::Builder::getLongitude() {
  return _builder.getDataField<double>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarState::Gps::Builder::setLongitude(double value) {
  _builder.setDataField<double>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline double StarPilotCarState::Gps::Reader::getAltitude() const {
  return _reader.getDataField<double>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}

inline double StarPilotCarState::Gps::Builder::getAltitude() {
  return _builder.getDataField<double>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarState::Gps::Builder::setAltitude(double value) {
  _builder.setDataField<double>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS, value);
}

inline float StarPilotCarState::Gps::Reader::getSpeed() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<8>() * ::capnp::ELEMENTS);
}

inline float StarPilotCarState::Gps::Builder::getSpeed() {
  return _builder.getDataField<float>(
      ::capnp::bounded<8>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarState::Gps::Builder::setSpeed(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<8>() * ::capnp::ELEMENTS, value);
}

inline float StarPilotCarState::Gps::Reader::getBearingDeg() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<9>() * ::capnp::ELEMENTS);
}

inline float StarPilotCarState::Gps::Builder::getBearingDeg() {
  return _builder.getDataField<float>(
      ::capnp::bounded<9>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarState::Gps::Builder::setBearingDeg(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<9>() * ::capnp::ELEMENTS, value);
}

inline float StarPilotCarState::Gps::Reader::getHorizontalAccuracy() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<10>() * ::capnp::ELEMENTS);
}

inline float StarPilotCarState::Gps::Builder::getHorizontalAccuracy() {
  return _builder.getDataField<float>(
      ::capnp::bounded<10>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarState::Gps::Builder::setHorizontalAccuracy(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<10>() * ::capnp::ELEMENTS, value);
}

inline float StarPilotCarState::Gps::Reader::getVerticalAccuracy() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<11>() * ::capnp::ELEMENTS);
}

inline float StarPilotCarState::Gps::Builder::getVerticalAccuracy() {
  return _builder.getDataField<float>(
      ::capnp::bounded<11>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarState::Gps::Builder::setVerticalAccuracy(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<11>() * ::capnp::ELEMENTS, value);
}

inline float StarPilotCarState::Gps::Reader::getBearingAccuracyDeg() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<12>() * ::capnp::ELEMENTS);
}

inline float StarPilotCarState::Gps::Builder::getBearingAccuracyDeg() {
  return _builder.getDataField<float>(
      ::capnp::bounded<12>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarState::Gps::Builder::setBearingAccuracyDeg(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<12>() * ::capnp::ELEMENTS, value);
}

inline float StarPilotCarState::Gps::Reader::getSpeedAccuracy() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<13>() * ::capnp::ELEMENTS);
}

inline float StarPilotCarState::Gps::Builder::getSpeedAccuracy() {
  return _builder.getDataField<float>(
      ::capnp::bounded<13>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarState::Gps::Builder::setSpeedAccuracy(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<13>() * ::capnp::ELEMENTS, value);
}

inline  ::int64_t StarPilotCarState::Gps::Reader::getUnixTimestampMillis() const {
  return _reader.getDataField< ::int64_t>(
      ::capnp::bounded<7>() * ::capnp::ELEMENTS);
}

inline  ::int64_t StarPilotCarState::Gps::Builder::getUnixTimestampMillis() {
  return _builder.getDataField< ::int64_t>(
      ::capnp::bounded<7>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarState::Gps::Builder::setUnixTimestampMillis( ::int64_t value) {
  _builder.setDataField< ::int64_t>(
      ::capnp::bounded<7>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotCarState::Gps::Reader::getHasFix() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<512>() * ::capnp::ELEMENTS);
}

inline bool StarPilotCarState::Gps::Builder::getHasFix() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<512>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarState::Gps::Builder::setHasFix(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<512>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotCarState::Gps::Reader::hasVNED() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotCarState::Gps::Builder::hasVNED() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::List<float,  ::capnp::Kind::PRIMITIVE>::Reader StarPilotCarState::Gps::Reader::getVNED() const {
  return ::capnp::_::PointerHelpers< ::capnp::List<float,  ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::capnp::List<float,  ::capnp::Kind::PRIMITIVE>::Builder StarPilotCarState::Gps::Builder::getVNED() {
  return ::capnp::_::PointerHelpers< ::capnp::List<float,  ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void StarPilotCarState::Gps::Builder::setVNED( ::capnp::List<float,  ::capnp::Kind::PRIMITIVE>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List<float,  ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline void StarPilotCarState::Gps::Builder::setVNED(::kj::ArrayPtr<const float> value) {
  ::capnp::_::PointerHelpers< ::capnp::List<float,  ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::capnp::List<float,  ::capnp::Kind::PRIMITIVE>::Builder StarPilotCarState::Gps::Builder::initVNED(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List<float,  ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void StarPilotCarState::Gps::Builder::adoptVNED(
    ::capnp::Orphan< ::capnp::List<float,  ::capnp::Kind::PRIMITIVE>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List<float,  ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List<float,  ::capnp::Kind::PRIMITIVE>> StarPilotCarState::Gps::Builder::disownVNED() {
  return ::capnp::_::PointerHelpers< ::capnp::List<float,  ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline  ::uint16_t StarPilotCarState::FeedbackPublication::Reader::getVersion() const {
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline  ::uint16_t StarPilotCarState::FeedbackPublication::Builder::getVersion() {
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarState::FeedbackPublication::Builder::setVersion( ::uint16_t value) {
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotCarState::FeedbackPublication::Reader::hasCardSession() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotCarState::FeedbackPublication::Builder::hasCardSession() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Data::Reader StarPilotCarState::FeedbackPublication::Reader::getCardSession() const {
  return ::capnp::_::PointerHelpers< ::capnp::Data>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::capnp::Data::Builder StarPilotCarState::FeedbackPublication::Builder::getCardSession() {
  return ::capnp::_::PointerHelpers< ::capnp::Data>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void StarPilotCarState::FeedbackPublication::Builder::setCardSession( ::capnp::Data::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Data>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Data::Builder StarPilotCarState::FeedbackPublication::Builder::initCardSession(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Data>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void StarPilotCarState::FeedbackPublication::Builder::adoptCardSession(
    ::capnp::Orphan< ::capnp::Data>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Data>::adopt(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Data> StarPilotCarState::FeedbackPublication::Builder::disownCardSession() {
  return ::capnp::_::PointerHelpers< ::capnp::Data>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline  ::uint64_t StarPilotCarState::FeedbackPublication::Reader::getPublicationSequence() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t StarPilotCarState::FeedbackPublication::Builder::getPublicationSequence() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarState::FeedbackPublication::Builder::setPublicationSequence( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t StarPilotCarState::FeedbackPublication::Reader::getPublicationMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t StarPilotCarState::FeedbackPublication::Builder::getPublicationMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarState::FeedbackPublication::Builder::setPublicationMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t StarPilotCarState::FeedbackPublication::Reader::getSourceCarStateMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t StarPilotCarState::FeedbackPublication::Builder::getSourceCarStateMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarState::FeedbackPublication::Builder::setSourceCarStateMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotCarState::FeedbackPublication::Reader::getOutputKnown() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS);
}

inline bool StarPilotCarState::FeedbackPublication::Builder::getOutputKnown() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarState::FeedbackPublication::Builder::setOutputKnown(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t StarPilotCarState::FeedbackPublication::Reader::getOutputControlMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t StarPilotCarState::FeedbackPublication::Builder::getOutputControlMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarState::FeedbackPublication::Builder::setOutputControlMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t StarPilotCarState::FeedbackPublication::Reader::getOutputApplyMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t StarPilotCarState::FeedbackPublication::Builder::getOutputApplyMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarState::FeedbackPublication::Builder::setOutputApplyMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotCarState::FeedbackPublication::Reader::hasOutputNativeIdentity() const {
  return !_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotCarState::FeedbackPublication::Builder::hasOutputNativeIdentity() {
  return !_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader StarPilotCarState::FeedbackPublication::Reader::getOutputNativeIdentity() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder StarPilotCarState::FeedbackPublication::Builder::getOutputNativeIdentity() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline void StarPilotCarState::FeedbackPublication::Builder::setOutputNativeIdentity( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder StarPilotCarState::FeedbackPublication::Builder::initOutputNativeIdentity(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), size);
}
inline void StarPilotCarState::FeedbackPublication::Builder::adoptOutputNativeIdentity(
    ::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> StarPilotCarState::FeedbackPublication::Builder::disownOutputNativeIdentity() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}

inline  ::uint64_t StarPilotCarState::FeedbackPublication::Reader::getOutputCarrierSequence() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t StarPilotCarState::FeedbackPublication::Builder::getOutputCarrierSequence() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarState::FeedbackPublication::Builder::setOutputCarrierSequence( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS, value);
}

inline float StarPilotCarState::FeedbackPublication::Reader::getReportedTorque() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline float StarPilotCarState::FeedbackPublication::Builder::getReportedTorque() {
  return _builder.getDataField<float>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarState::FeedbackPublication::Builder::setReportedTorque(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotCarState::FeedbackPublication::Reader::getOutputValid() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<17>() * ::capnp::ELEMENTS);
}

inline bool StarPilotCarState::FeedbackPublication::Builder::getOutputValid() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<17>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarState::FeedbackPublication::Builder::setOutputValid(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<17>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotCarState::FeedbackPublication::Reader::hasCoBodySha256() const {
  return !_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotCarState::FeedbackPublication::Builder::hasCoBodySha256() {
  return !_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Data::Reader StarPilotCarState::FeedbackPublication::Reader::getCoBodySha256() const {
  return ::capnp::_::PointerHelpers< ::capnp::Data>::get(_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline  ::capnp::Data::Builder StarPilotCarState::FeedbackPublication::Builder::getCoBodySha256() {
  return ::capnp::_::PointerHelpers< ::capnp::Data>::get(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline void StarPilotCarState::FeedbackPublication::Builder::setCoBodySha256( ::capnp::Data::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Data>::set(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Data::Builder StarPilotCarState::FeedbackPublication::Builder::initCoBodySha256(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Data>::init(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), size);
}
inline void StarPilotCarState::FeedbackPublication::Builder::adoptCoBodySha256(
    ::capnp::Orphan< ::capnp::Data>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Data>::adopt(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Data> StarPilotCarState::FeedbackPublication::Builder::disownCoBodySha256() {
  return ::capnp::_::PointerHelpers< ::capnp::Data>::disown(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}

inline bool StarPilotCarState::FeedbackPublication::Reader::hasApplyEvidenceSha256() const {
  return !_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotCarState::FeedbackPublication::Builder::hasApplyEvidenceSha256() {
  return !_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Data::Reader StarPilotCarState::FeedbackPublication::Reader::getApplyEvidenceSha256() const {
  return ::capnp::_::PointerHelpers< ::capnp::Data>::get(_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline  ::capnp::Data::Builder StarPilotCarState::FeedbackPublication::Builder::getApplyEvidenceSha256() {
  return ::capnp::_::PointerHelpers< ::capnp::Data>::get(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline void StarPilotCarState::FeedbackPublication::Builder::setApplyEvidenceSha256( ::capnp::Data::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Data>::set(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Data::Builder StarPilotCarState::FeedbackPublication::Builder::initApplyEvidenceSha256(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Data>::init(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), size);
}
inline void StarPilotCarState::FeedbackPublication::Builder::adoptApplyEvidenceSha256(
    ::capnp::Orphan< ::capnp::Data>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Data>::adopt(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Data> StarPilotCarState::FeedbackPublication::Builder::disownApplyEvidenceSha256() {
  return ::capnp::_::PointerHelpers< ::capnp::Data>::disown(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}

inline bool StarPilotCarState::FeedbackPublication::Reader::hasSourceEpoch() const {
  return !_reader.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotCarState::FeedbackPublication::Builder::hasSourceEpoch() {
  return !_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader StarPilotCarState::FeedbackPublication::Reader::getSourceEpoch() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder StarPilotCarState::FeedbackPublication::Builder::getSourceEpoch() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}
inline void StarPilotCarState::FeedbackPublication::Builder::setSourceEpoch( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder StarPilotCarState::FeedbackPublication::Builder::initSourceEpoch(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), size);
}
inline void StarPilotCarState::FeedbackPublication::Builder::adoptSourceEpoch(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> StarPilotCarState::FeedbackPublication::Builder::disownSourceEpoch() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}

inline bool StarPilotCarState::FeedbackPublication::Reader::hasCpSha256() const {
  return !_reader.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotCarState::FeedbackPublication::Builder::hasCpSha256() {
  return !_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader StarPilotCarState::FeedbackPublication::Reader::getCpSha256() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder StarPilotCarState::FeedbackPublication::Builder::getCpSha256() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS));
}
inline void StarPilotCarState::FeedbackPublication::Builder::setCpSha256( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder StarPilotCarState::FeedbackPublication::Builder::initCpSha256(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS), size);
}
inline void StarPilotCarState::FeedbackPublication::Builder::adoptCpSha256(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> StarPilotCarState::FeedbackPublication::Builder::disownCpSha256() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS));
}

inline  ::uint64_t StarPilotCarState::FeedbackPublication::Reader::getCarrierObservedMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<7>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t StarPilotCarState::FeedbackPublication::Builder::getCarrierObservedMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<7>() * ::capnp::ELEMENTS);
}
inline void StarPilotCarState::FeedbackPublication::Builder::setCarrierObservedMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<7>() * ::capnp::ELEMENTS, value);
}

inline  ::uint16_t StarPilotLongitudinalPlan::Reader::getVersion() const {
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline  ::uint16_t StarPilotLongitudinalPlan::Builder::getVersion() {
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void StarPilotLongitudinalPlan::Builder::setVersion( ::uint16_t value) {
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t StarPilotLongitudinalPlan::Reader::getSourcePlanMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t StarPilotLongitudinalPlan::Builder::getSourcePlanMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void StarPilotLongitudinalPlan::Builder::setSourcePlanMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t StarPilotLongitudinalPlan::Reader::getModelMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t StarPilotLongitudinalPlan::Builder::getModelMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void StarPilotLongitudinalPlan::Builder::setModelMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t StarPilotLongitudinalPlan::Reader::getDriveStartMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t StarPilotLongitudinalPlan::Builder::getDriveStartMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}
inline void StarPilotLongitudinalPlan::Builder::setDriveStartMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotLongitudinalPlan::Reader::getForceStopHolding() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS);
}

inline bool StarPilotLongitudinalPlan::Builder::getForceStopHolding() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS);
}
inline void StarPilotLongitudinalPlan::Builder::setForceStopHolding(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS, value);
}

inline bool SlcState::Reader::hasSlotId() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool SlcState::Builder::hasSlotId() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader SlcState::Reader::getSlotId() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder SlcState::Builder::getSlotId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void SlcState::Builder::setSlotId( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder SlcState::Builder::initSlotId(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void SlcState::Builder::adoptSlotId(
    ::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> SlcState::Builder::disownSlotId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline bool SlcState::Reader::hasSlotName() const {
  return !_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline bool SlcState::Builder::hasSlotName() {
  return !_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader SlcState::Reader::getSlotName() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder SlcState::Builder::getSlotName() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline void SlcState::Builder::setSlotName( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder SlcState::Builder::initSlotName(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), size);
}
inline void SlcState::Builder::adoptSlotName(
    ::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> SlcState::Builder::disownSlotName() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}

inline bool SlcState::Reader::hasVariant() const {
  return !_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline bool SlcState::Builder::hasVariant() {
  return !_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader SlcState::Reader::getVariant() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder SlcState::Builder::getVariant() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline void SlcState::Builder::setVariant( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder SlcState::Builder::initVariant(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), size);
}
inline void SlcState::Builder::adoptVariant(
    ::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> SlcState::Builder::disownVariant() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}

inline bool SlcState::Reader::hasVariantLabel() const {
  return !_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline bool SlcState::Builder::hasVariantLabel() {
  return !_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader SlcState::Reader::getVariantLabel() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder SlcState::Builder::getVariantLabel() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline void SlcState::Builder::setVariantLabel( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder SlcState::Builder::initVariantLabel(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), size);
}
inline void SlcState::Builder::adoptVariantLabel(
    ::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> SlcState::Builder::disownVariantLabel() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}

inline bool SlcState::Reader::hasReason() const {
  return !_reader.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS).isNull();
}
inline bool SlcState::Builder::hasReason() {
  return !_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader SlcState::Reader::getReason() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder SlcState::Builder::getReason() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}
inline void SlcState::Builder::setReason( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder SlcState::Builder::initReason(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), size);
}
inline void SlcState::Builder::adoptReason(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> SlcState::Builder::disownReason() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}

inline  ::uint64_t SlcState::Reader::getWallTimeNanos() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcState::Builder::getWallTimeNanos() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void SlcState::Builder::setWallTimeNanos( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool SlcState::Reader::hasSessionId() const {
  return !_reader.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS).isNull();
}
inline bool SlcState::Builder::hasSessionId() {
  return !_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader SlcState::Reader::getSessionId() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder SlcState::Builder::getSessionId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS));
}
inline void SlcState::Builder::setSessionId( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder SlcState::Builder::initSessionId(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS), size);
}
inline void SlcState::Builder::adoptSessionId(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> SlcState::Builder::disownSessionId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS));
}

inline  ::uint64_t SlcState::Reader::getFrameMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcState::Builder::getFrameMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void SlcState::Builder::setFrameMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline bool SlcState::Reader::getEnabled() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<128>() * ::capnp::ELEMENTS);
}

inline bool SlcState::Builder::getEnabled() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<128>() * ::capnp::ELEMENTS);
}
inline void SlcState::Builder::setEnabled(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<128>() * ::capnp::ELEMENTS, value);
}

inline bool SlcState::Reader::getDisplayOnly() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<129>() * ::capnp::ELEMENTS);
}

inline bool SlcState::Builder::getDisplayOnly() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<129>() * ::capnp::ELEMENTS);
}
inline void SlcState::Builder::setDisplayOnly(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<129>() * ::capnp::ELEMENTS, value);
}

inline bool SlcState::Reader::hasObservationKind() const {
  return !_reader.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS).isNull();
}
inline bool SlcState::Builder::hasObservationKind() {
  return !_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader SlcState::Reader::getObservationKind() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder SlcState::Builder::getObservationKind() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS));
}
inline void SlcState::Builder::setObservationKind( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder SlcState::Builder::initObservationKind(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS), size);
}
inline void SlcState::Builder::adoptObservationKind(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> SlcState::Builder::disownObservationKind() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS));
}

inline bool SlcState::Reader::hasSource() const {
  return !_reader.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS).isNull();
}
inline bool SlcState::Builder::hasSource() {
  return !_builder.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader SlcState::Reader::getSource() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder SlcState::Builder::getSource() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS));
}
inline void SlcState::Builder::setSource( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder SlcState::Builder::initSource(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS), size);
}
inline void SlcState::Builder::adoptSource(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> SlcState::Builder::disownSource() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS));
}

inline float SlcState::Reader::getSpeedLimit() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}

inline float SlcState::Builder::getSpeedLimit() {
  return _builder.getDataField<float>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}
inline void SlcState::Builder::setSpeedLimit(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS, value);
}

inline float SlcState::Reader::getAcceptedSpeedLimit() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS);
}

inline float SlcState::Builder::getAcceptedSpeedLimit() {
  return _builder.getDataField<float>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS);
}
inline void SlcState::Builder::setAcceptedSpeedLimit(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS, value);
}

inline bool SlcState::Reader::getHasAccepted() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<130>() * ::capnp::ELEMENTS);
}

inline bool SlcState::Builder::getHasAccepted() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<130>() * ::capnp::ELEMENTS);
}
inline void SlcState::Builder::setHasAccepted(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<130>() * ::capnp::ELEMENTS, value);
}

inline float SlcState::Reader::getOffset() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<7>() * ::capnp::ELEMENTS);
}

inline float SlcState::Builder::getOffset() {
  return _builder.getDataField<float>(
      ::capnp::bounded<7>() * ::capnp::ELEMENTS);
}
inline void SlcState::Builder::setOffset(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<7>() * ::capnp::ELEMENTS, value);
}

inline float SlcState::Reader::getEffectiveCap() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<8>() * ::capnp::ELEMENTS);
}

inline float SlcState::Builder::getEffectiveCap() {
  return _builder.getDataField<float>(
      ::capnp::bounded<8>() * ::capnp::ELEMENTS);
}
inline void SlcState::Builder::setEffectiveCap(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<8>() * ::capnp::ELEMENTS, value);
}

inline bool SlcState::Reader::getHasCeiling() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<131>() * ::capnp::ELEMENTS);
}

inline bool SlcState::Builder::getHasCeiling() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<131>() * ::capnp::ELEMENTS);
}
inline void SlcState::Builder::setHasCeiling(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<131>() * ::capnp::ELEMENTS, value);
}

inline float SlcState::Reader::getPendingSpeedLimit() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<9>() * ::capnp::ELEMENTS);
}

inline float SlcState::Builder::getPendingSpeedLimit() {
  return _builder.getDataField<float>(
      ::capnp::bounded<9>() * ::capnp::ELEMENTS);
}
inline void SlcState::Builder::setPendingSpeedLimit(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<9>() * ::capnp::ELEMENTS, value);
}

inline bool SlcState::Reader::getHasPending() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<132>() * ::capnp::ELEMENTS);
}

inline bool SlcState::Builder::getHasPending() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<132>() * ::capnp::ELEMENTS);
}
inline void SlcState::Builder::setHasPending(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<132>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t SlcState::Reader::getDecisionId() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcState::Builder::getDecisionId() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}
inline void SlcState::Builder::setDecisionId( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t SlcState::Reader::getPresentationId() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcState::Builder::getPresentationId() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS);
}
inline void SlcState::Builder::setPresentationId( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS, value);
}

inline bool SlcState::Reader::hasStatus() const {
  return !_reader.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS).isNull();
}
inline bool SlcState::Builder::hasStatus() {
  return !_builder.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader SlcState::Reader::getStatus() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder SlcState::Builder::getStatus() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS));
}
inline void SlcState::Builder::setStatus( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder SlcState::Builder::initStatus(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS), size);
}
inline void SlcState::Builder::adoptStatus(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> SlcState::Builder::disownStatus() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS));
}

inline  ::uint64_t SlcState::Reader::getActionSequenceId() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<7>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcState::Builder::getActionSequenceId() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<7>() * ::capnp::ELEMENTS);
}
inline void SlcState::Builder::setActionSequenceId( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<7>() * ::capnp::ELEMENTS, value);
}

inline bool SlcState::Reader::hasActionStatus() const {
  return !_reader.getPointerField(
      ::capnp::bounded<9>() * ::capnp::POINTERS).isNull();
}
inline bool SlcState::Builder::hasActionStatus() {
  return !_builder.getPointerField(
      ::capnp::bounded<9>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader SlcState::Reader::getActionStatus() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<9>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder SlcState::Builder::getActionStatus() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<9>() * ::capnp::POINTERS));
}
inline void SlcState::Builder::setActionStatus( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<9>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder SlcState::Builder::initActionStatus(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<9>() * ::capnp::POINTERS), size);
}
inline void SlcState::Builder::adoptActionStatus(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<9>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> SlcState::Builder::disownActionStatus() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<9>() * ::capnp::POINTERS));
}

inline bool SlcState::Reader::hasSourceProducerSessionId() const {
  return !_reader.getPointerField(
      ::capnp::bounded<10>() * ::capnp::POINTERS).isNull();
}
inline bool SlcState::Builder::hasSourceProducerSessionId() {
  return !_builder.getPointerField(
      ::capnp::bounded<10>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader SlcState::Reader::getSourceProducerSessionId() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<10>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder SlcState::Builder::getSourceProducerSessionId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<10>() * ::capnp::POINTERS));
}
inline void SlcState::Builder::setSourceProducerSessionId( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<10>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder SlcState::Builder::initSourceProducerSessionId(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<10>() * ::capnp::POINTERS), size);
}
inline void SlcState::Builder::adoptSourceProducerSessionId(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<10>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> SlcState::Builder::disownSourceProducerSessionId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<10>() * ::capnp::POINTERS));
}

inline  ::uint32_t SlcState::Reader::getSourceEpisode() const {
  return _reader.getDataField< ::uint32_t>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS);
}

inline  ::uint32_t SlcState::Builder::getSourceEpisode() {
  return _builder.getDataField< ::uint32_t>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS);
}
inline void SlcState::Builder::setSourceEpisode( ::uint32_t value) {
  _builder.setDataField< ::uint32_t>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t SlcState::Reader::getSourceObservedMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<9>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcState::Builder::getSourceObservedMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<9>() * ::capnp::ELEMENTS);
}
inline void SlcState::Builder::setSourceObservedMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<9>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t SlcState::Reader::getSourceValidUntilMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<10>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcState::Builder::getSourceValidUntilMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<10>() * ::capnp::ELEMENTS);
}
inline void SlcState::Builder::setSourceValidUntilMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<10>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t SlcState::Reader::getCommandId() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<11>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcState::Builder::getCommandId() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<11>() * ::capnp::ELEMENTS);
}
inline void SlcState::Builder::setCommandId( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<11>() * ::capnp::ELEMENTS, value);
}

inline bool SlcState::Reader::hasCommandStatus() const {
  return !_reader.getPointerField(
      ::capnp::bounded<11>() * ::capnp::POINTERS).isNull();
}
inline bool SlcState::Builder::hasCommandStatus() {
  return !_builder.getPointerField(
      ::capnp::bounded<11>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader SlcState::Reader::getCommandStatus() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<11>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder SlcState::Builder::getCommandStatus() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<11>() * ::capnp::POINTERS));
}
inline void SlcState::Builder::setCommandStatus( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<11>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder SlcState::Builder::initCommandStatus(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<11>() * ::capnp::POINTERS), size);
}
inline void SlcState::Builder::adoptCommandStatus(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<11>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> SlcState::Builder::disownCommandStatus() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<11>() * ::capnp::POINTERS));
}

inline bool SlcState::Reader::hasCurve() const {
  return !_reader.getPointerField(
      ::capnp::bounded<12>() * ::capnp::POINTERS).isNull();
}
inline bool SlcState::Builder::hasCurve() {
  return !_builder.getPointerField(
      ::capnp::bounded<12>() * ::capnp::POINTERS).isNull();
}
inline  ::cereal::SlcState::CurveState::Reader SlcState::Reader::getCurve() const {
  return ::capnp::_::PointerHelpers< ::cereal::SlcState::CurveState>::get(_reader.getPointerField(
      ::capnp::bounded<12>() * ::capnp::POINTERS));
}
inline  ::cereal::SlcState::CurveState::Builder SlcState::Builder::getCurve() {
  return ::capnp::_::PointerHelpers< ::cereal::SlcState::CurveState>::get(_builder.getPointerField(
      ::capnp::bounded<12>() * ::capnp::POINTERS));
}
#if !CAPNP_LITE
inline  ::cereal::SlcState::CurveState::Pipeline SlcState::Pipeline::getCurve() {
  return  ::cereal::SlcState::CurveState::Pipeline(_typeless.getPointerField(12));
}
#endif  // !CAPNP_LITE
inline void SlcState::Builder::setCurve( ::cereal::SlcState::CurveState::Reader value) {
  ::capnp::_::PointerHelpers< ::cereal::SlcState::CurveState>::set(_builder.getPointerField(
      ::capnp::bounded<12>() * ::capnp::POINTERS), value);
}
inline  ::cereal::SlcState::CurveState::Builder SlcState::Builder::initCurve() {
  return ::capnp::_::PointerHelpers< ::cereal::SlcState::CurveState>::init(_builder.getPointerField(
      ::capnp::bounded<12>() * ::capnp::POINTERS));
}
inline void SlcState::Builder::adoptCurve(
    ::capnp::Orphan< ::cereal::SlcState::CurveState>&& value) {
  ::capnp::_::PointerHelpers< ::cereal::SlcState::CurveState>::adopt(_builder.getPointerField(
      ::capnp::bounded<12>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::cereal::SlcState::CurveState> SlcState::Builder::disownCurve() {
  return ::capnp::_::PointerHelpers< ::cereal::SlcState::CurveState>::disown(_builder.getPointerField(
      ::capnp::bounded<12>() * ::capnp::POINTERS));
}

inline bool SlcState::Reader::hasConditionalMode() const {
  return !_reader.getPointerField(
      ::capnp::bounded<13>() * ::capnp::POINTERS).isNull();
}
inline bool SlcState::Builder::hasConditionalMode() {
  return !_builder.getPointerField(
      ::capnp::bounded<13>() * ::capnp::POINTERS).isNull();
}
inline  ::cereal::SlcState::ConditionalModeState::Reader SlcState::Reader::getConditionalMode() const {
  return ::capnp::_::PointerHelpers< ::cereal::SlcState::ConditionalModeState>::get(_reader.getPointerField(
      ::capnp::bounded<13>() * ::capnp::POINTERS));
}
inline  ::cereal::SlcState::ConditionalModeState::Builder SlcState::Builder::getConditionalMode() {
  return ::capnp::_::PointerHelpers< ::cereal::SlcState::ConditionalModeState>::get(_builder.getPointerField(
      ::capnp::bounded<13>() * ::capnp::POINTERS));
}
#if !CAPNP_LITE
inline  ::cereal::SlcState::ConditionalModeState::Pipeline SlcState::Pipeline::getConditionalMode() {
  return  ::cereal::SlcState::ConditionalModeState::Pipeline(_typeless.getPointerField(13));
}
#endif  // !CAPNP_LITE
inline void SlcState::Builder::setConditionalMode( ::cereal::SlcState::ConditionalModeState::Reader value) {
  ::capnp::_::PointerHelpers< ::cereal::SlcState::ConditionalModeState>::set(_builder.getPointerField(
      ::capnp::bounded<13>() * ::capnp::POINTERS), value);
}
inline  ::cereal::SlcState::ConditionalModeState::Builder SlcState::Builder::initConditionalMode() {
  return ::capnp::_::PointerHelpers< ::cereal::SlcState::ConditionalModeState>::init(_builder.getPointerField(
      ::capnp::bounded<13>() * ::capnp::POINTERS));
}
inline void SlcState::Builder::adoptConditionalMode(
    ::capnp::Orphan< ::cereal::SlcState::ConditionalModeState>&& value) {
  ::capnp::_::PointerHelpers< ::cereal::SlcState::ConditionalModeState>::adopt(_builder.getPointerField(
      ::capnp::bounded<13>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::cereal::SlcState::ConditionalModeState> SlcState::Builder::disownConditionalMode() {
  return ::capnp::_::PointerHelpers< ::cereal::SlcState::ConditionalModeState>::disown(_builder.getPointerField(
      ::capnp::bounded<13>() * ::capnp::POINTERS));
}

inline bool SlcState::Reader::hasTrafficMode() const {
  return !_reader.getPointerField(
      ::capnp::bounded<14>() * ::capnp::POINTERS).isNull();
}
inline bool SlcState::Builder::hasTrafficMode() {
  return !_builder.getPointerField(
      ::capnp::bounded<14>() * ::capnp::POINTERS).isNull();
}
inline  ::cereal::SlcState::TrafficModeState::Reader SlcState::Reader::getTrafficMode() const {
  return ::capnp::_::PointerHelpers< ::cereal::SlcState::TrafficModeState>::get(_reader.getPointerField(
      ::capnp::bounded<14>() * ::capnp::POINTERS));
}
inline  ::cereal::SlcState::TrafficModeState::Builder SlcState::Builder::getTrafficMode() {
  return ::capnp::_::PointerHelpers< ::cereal::SlcState::TrafficModeState>::get(_builder.getPointerField(
      ::capnp::bounded<14>() * ::capnp::POINTERS));
}
#if !CAPNP_LITE
inline  ::cereal::SlcState::TrafficModeState::Pipeline SlcState::Pipeline::getTrafficMode() {
  return  ::cereal::SlcState::TrafficModeState::Pipeline(_typeless.getPointerField(14));
}
#endif  // !CAPNP_LITE
inline void SlcState::Builder::setTrafficMode( ::cereal::SlcState::TrafficModeState::Reader value) {
  ::capnp::_::PointerHelpers< ::cereal::SlcState::TrafficModeState>::set(_builder.getPointerField(
      ::capnp::bounded<14>() * ::capnp::POINTERS), value);
}
inline  ::cereal::SlcState::TrafficModeState::Builder SlcState::Builder::initTrafficMode() {
  return ::capnp::_::PointerHelpers< ::cereal::SlcState::TrafficModeState>::init(_builder.getPointerField(
      ::capnp::bounded<14>() * ::capnp::POINTERS));
}
inline void SlcState::Builder::adoptTrafficMode(
    ::capnp::Orphan< ::cereal::SlcState::TrafficModeState>&& value) {
  ::capnp::_::PointerHelpers< ::cereal::SlcState::TrafficModeState>::adopt(_builder.getPointerField(
      ::capnp::bounded<14>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::cereal::SlcState::TrafficModeState> SlcState::Builder::disownTrafficMode() {
  return ::capnp::_::PointerHelpers< ::cereal::SlcState::TrafficModeState>::disown(_builder.getPointerField(
      ::capnp::bounded<14>() * ::capnp::POINTERS));
}

inline bool SlcState::Reader::hasSwitchbackMode() const {
  return !_reader.getPointerField(
      ::capnp::bounded<15>() * ::capnp::POINTERS).isNull();
}
inline bool SlcState::Builder::hasSwitchbackMode() {
  return !_builder.getPointerField(
      ::capnp::bounded<15>() * ::capnp::POINTERS).isNull();
}
inline  ::cereal::SlcState::SwitchbackModeState::Reader SlcState::Reader::getSwitchbackMode() const {
  return ::capnp::_::PointerHelpers< ::cereal::SlcState::SwitchbackModeState>::get(_reader.getPointerField(
      ::capnp::bounded<15>() * ::capnp::POINTERS));
}
inline  ::cereal::SlcState::SwitchbackModeState::Builder SlcState::Builder::getSwitchbackMode() {
  return ::capnp::_::PointerHelpers< ::cereal::SlcState::SwitchbackModeState>::get(_builder.getPointerField(
      ::capnp::bounded<15>() * ::capnp::POINTERS));
}
#if !CAPNP_LITE
inline  ::cereal::SlcState::SwitchbackModeState::Pipeline SlcState::Pipeline::getSwitchbackMode() {
  return  ::cereal::SlcState::SwitchbackModeState::Pipeline(_typeless.getPointerField(15));
}
#endif  // !CAPNP_LITE
inline void SlcState::Builder::setSwitchbackMode( ::cereal::SlcState::SwitchbackModeState::Reader value) {
  ::capnp::_::PointerHelpers< ::cereal::SlcState::SwitchbackModeState>::set(_builder.getPointerField(
      ::capnp::bounded<15>() * ::capnp::POINTERS), value);
}
inline  ::cereal::SlcState::SwitchbackModeState::Builder SlcState::Builder::initSwitchbackMode() {
  return ::capnp::_::PointerHelpers< ::cereal::SlcState::SwitchbackModeState>::init(_builder.getPointerField(
      ::capnp::bounded<15>() * ::capnp::POINTERS));
}
inline void SlcState::Builder::adoptSwitchbackMode(
    ::capnp::Orphan< ::cereal::SlcState::SwitchbackModeState>&& value) {
  ::capnp::_::PointerHelpers< ::cereal::SlcState::SwitchbackModeState>::adopt(_builder.getPointerField(
      ::capnp::bounded<15>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::cereal::SlcState::SwitchbackModeState> SlcState::Builder::disownSwitchbackMode() {
  return ::capnp::_::PointerHelpers< ::cereal::SlcState::SwitchbackModeState>::disown(_builder.getPointerField(
      ::capnp::bounded<15>() * ::capnp::POINTERS));
}

inline bool SlcState::Reader::hasAcceptedSource() const {
  return !_reader.getPointerField(
      ::capnp::bounded<16>() * ::capnp::POINTERS).isNull();
}
inline bool SlcState::Builder::hasAcceptedSource() {
  return !_builder.getPointerField(
      ::capnp::bounded<16>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader SlcState::Reader::getAcceptedSource() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<16>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder SlcState::Builder::getAcceptedSource() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<16>() * ::capnp::POINTERS));
}
inline void SlcState::Builder::setAcceptedSource( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<16>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder SlcState::Builder::initAcceptedSource(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<16>() * ::capnp::POINTERS), size);
}
inline void SlcState::Builder::adoptAcceptedSource(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<16>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> SlcState::Builder::disownAcceptedSource() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<16>() * ::capnp::POINTERS));
}

inline bool SlcState::Reader::hasPendingSource() const {
  return !_reader.getPointerField(
      ::capnp::bounded<17>() * ::capnp::POINTERS).isNull();
}
inline bool SlcState::Builder::hasPendingSource() {
  return !_builder.getPointerField(
      ::capnp::bounded<17>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader SlcState::Reader::getPendingSource() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<17>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder SlcState::Builder::getPendingSource() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<17>() * ::capnp::POINTERS));
}
inline void SlcState::Builder::setPendingSource( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<17>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder SlcState::Builder::initPendingSource(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<17>() * ::capnp::POINTERS), size);
}
inline void SlcState::Builder::adoptPendingSource(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<17>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> SlcState::Builder::disownPendingSource() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<17>() * ::capnp::POINTERS));
}

inline float SlcState::Reader::getEffectiveClusterTarget() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<17>() * ::capnp::ELEMENTS);
}

inline float SlcState::Builder::getEffectiveClusterTarget() {
  return _builder.getDataField<float>(
      ::capnp::bounded<17>() * ::capnp::ELEMENTS);
}
inline void SlcState::Builder::setEffectiveClusterTarget(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<17>() * ::capnp::ELEMENTS, value);
}

inline bool SlcState::Reader::getHasEffectiveClusterTarget() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<133>() * ::capnp::ELEMENTS);
}

inline bool SlcState::Builder::getHasEffectiveClusterTarget() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<133>() * ::capnp::ELEMENTS);
}
inline void SlcState::Builder::setHasEffectiveClusterTarget(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<133>() * ::capnp::ELEMENTS, value);
}

inline bool SlcState::Reader::getIsLimitingMaxSet() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<134>() * ::capnp::ELEMENTS);
}

inline bool SlcState::Builder::getIsLimitingMaxSet() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<134>() * ::capnp::ELEMENTS);
}
inline void SlcState::Builder::setIsLimitingMaxSet(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<134>() * ::capnp::ELEMENTS, value);
}

inline bool SlcState::Reader::getDriverOverrideActive() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<135>() * ::capnp::ELEMENTS);
}

inline bool SlcState::Builder::getDriverOverrideActive() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<135>() * ::capnp::ELEMENTS);
}
inline void SlcState::Builder::setDriverOverrideActive(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<135>() * ::capnp::ELEMENTS, value);
}

inline bool SlcState::Reader::hasSourceReadings() const {
  return !_reader.getPointerField(
      ::capnp::bounded<18>() * ::capnp::POINTERS).isNull();
}
inline bool SlcState::Builder::hasSourceReadings() {
  return !_builder.getPointerField(
      ::capnp::bounded<18>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::List< ::cereal::SlcState::SourceReading,  ::capnp::Kind::STRUCT>::Reader SlcState::Reader::getSourceReadings() const {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::SlcState::SourceReading,  ::capnp::Kind::STRUCT>>::get(_reader.getPointerField(
      ::capnp::bounded<18>() * ::capnp::POINTERS));
}
inline  ::capnp::List< ::cereal::SlcState::SourceReading,  ::capnp::Kind::STRUCT>::Builder SlcState::Builder::getSourceReadings() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::SlcState::SourceReading,  ::capnp::Kind::STRUCT>>::get(_builder.getPointerField(
      ::capnp::bounded<18>() * ::capnp::POINTERS));
}
inline void SlcState::Builder::setSourceReadings( ::capnp::List< ::cereal::SlcState::SourceReading,  ::capnp::Kind::STRUCT>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::SlcState::SourceReading,  ::capnp::Kind::STRUCT>>::set(_builder.getPointerField(
      ::capnp::bounded<18>() * ::capnp::POINTERS), value);
}
inline  ::capnp::List< ::cereal::SlcState::SourceReading,  ::capnp::Kind::STRUCT>::Builder SlcState::Builder::initSourceReadings(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::SlcState::SourceReading,  ::capnp::Kind::STRUCT>>::init(_builder.getPointerField(
      ::capnp::bounded<18>() * ::capnp::POINTERS), size);
}
inline void SlcState::Builder::adoptSourceReadings(
    ::capnp::Orphan< ::capnp::List< ::cereal::SlcState::SourceReading,  ::capnp::Kind::STRUCT>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::SlcState::SourceReading,  ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField(
      ::capnp::bounded<18>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List< ::cereal::SlcState::SourceReading,  ::capnp::Kind::STRUCT>> SlcState::Builder::disownSourceReadings() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::SlcState::SourceReading,  ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField(
      ::capnp::bounded<18>() * ::capnp::POINTERS));
}

inline float SlcState::Reader::getAcceptedAdjustedLimit() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<24>() * ::capnp::ELEMENTS);
}

inline float SlcState::Builder::getAcceptedAdjustedLimit() {
  return _builder.getDataField<float>(
      ::capnp::bounded<24>() * ::capnp::ELEMENTS);
}
inline void SlcState::Builder::setAcceptedAdjustedLimit(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<24>() * ::capnp::ELEMENTS, value);
}

inline bool SlcState::Reader::getHasAcceptedAdjustedLimit() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<136>() * ::capnp::ELEMENTS);
}

inline bool SlcState::Builder::getHasAcceptedAdjustedLimit() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<136>() * ::capnp::ELEMENTS);
}
inline void SlcState::Builder::setHasAcceptedAdjustedLimit(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<136>() * ::capnp::ELEMENTS, value);
}

inline float SlcState::Reader::getPendingAdjustedLimit() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<25>() * ::capnp::ELEMENTS);
}

inline float SlcState::Builder::getPendingAdjustedLimit() {
  return _builder.getDataField<float>(
      ::capnp::bounded<25>() * ::capnp::ELEMENTS);
}
inline void SlcState::Builder::setPendingAdjustedLimit(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<25>() * ::capnp::ELEMENTS, value);
}

inline bool SlcState::Reader::getHasPendingAdjustedLimit() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<137>() * ::capnp::ELEMENTS);
}

inline bool SlcState::Builder::getHasPendingAdjustedLimit() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<137>() * ::capnp::ELEMENTS);
}
inline void SlcState::Builder::setHasPendingAdjustedLimit(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<137>() * ::capnp::ELEMENTS, value);
}

inline float SlcState::Reader::getPresentationAdjustedLimit() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<26>() * ::capnp::ELEMENTS);
}

inline float SlcState::Builder::getPresentationAdjustedLimit() {
  return _builder.getDataField<float>(
      ::capnp::bounded<26>() * ::capnp::ELEMENTS);
}
inline void SlcState::Builder::setPresentationAdjustedLimit(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<26>() * ::capnp::ELEMENTS, value);
}

inline bool SlcState::Reader::getHasPresentationAdjustedLimit() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<138>() * ::capnp::ELEMENTS);
}

inline bool SlcState::Builder::getHasPresentationAdjustedLimit() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<138>() * ::capnp::ELEMENTS);
}
inline void SlcState::Builder::setHasPresentationAdjustedLimit(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<138>() * ::capnp::ELEMENTS, value);
}

inline bool SlcState::Reader::hasOverrideBasis() const {
  return !_reader.getPointerField(
      ::capnp::bounded<19>() * ::capnp::POINTERS).isNull();
}
inline bool SlcState::Builder::hasOverrideBasis() {
  return !_builder.getPointerField(
      ::capnp::bounded<19>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader SlcState::Reader::getOverrideBasis() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<19>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder SlcState::Builder::getOverrideBasis() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<19>() * ::capnp::POINTERS));
}
inline void SlcState::Builder::setOverrideBasis( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<19>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder SlcState::Builder::initOverrideBasis(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<19>() * ::capnp::POINTERS), size);
}
inline void SlcState::Builder::adoptOverrideBasis(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<19>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> SlcState::Builder::disownOverrideBasis() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<19>() * ::capnp::POINTERS));
}

inline bool SlcState::Reader::getRetainedOverride() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<139>() * ::capnp::ELEMENTS);
}

inline bool SlcState::Builder::getRetainedOverride() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<139>() * ::capnp::ELEMENTS);
}
inline void SlcState::Builder::setRetainedOverride(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<139>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t SlcState::Reader::getCommandActionSequenceId() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<14>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcState::Builder::getCommandActionSequenceId() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<14>() * ::capnp::ELEMENTS);
}
inline void SlcState::Builder::setCommandActionSequenceId( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<14>() * ::capnp::ELEMENTS, value);
}

inline bool SlcState::Reader::getAutomaticAdoptionPending() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<140>() * ::capnp::ELEMENTS);
}

inline bool SlcState::Builder::getAutomaticAdoptionPending() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<140>() * ::capnp::ELEMENTS);
}
inline void SlcState::Builder::setAutomaticAdoptionPending(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<140>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t SlcState::Reader::getPendingSinceMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<15>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcState::Builder::getPendingSinceMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<15>() * ::capnp::ELEMENTS);
}
inline void SlcState::Builder::setPendingSinceMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<15>() * ::capnp::ELEMENTS, value);
}

inline float SlcState::Reader::getLastReceivedSpeedLimit() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<27>() * ::capnp::ELEMENTS);
}

inline float SlcState::Builder::getLastReceivedSpeedLimit() {
  return _builder.getDataField<float>(
      ::capnp::bounded<27>() * ::capnp::ELEMENTS);
}
inline void SlcState::Builder::setLastReceivedSpeedLimit(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<27>() * ::capnp::ELEMENTS, value);
}

inline bool SlcState::Reader::hasLastReceivedSource() const {
  return !_reader.getPointerField(
      ::capnp::bounded<20>() * ::capnp::POINTERS).isNull();
}
inline bool SlcState::Builder::hasLastReceivedSource() {
  return !_builder.getPointerField(
      ::capnp::bounded<20>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader SlcState::Reader::getLastReceivedSource() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<20>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder SlcState::Builder::getLastReceivedSource() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<20>() * ::capnp::POINTERS));
}
inline void SlcState::Builder::setLastReceivedSource( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<20>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder SlcState::Builder::initLastReceivedSource(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<20>() * ::capnp::POINTERS), size);
}
inline void SlcState::Builder::adoptLastReceivedSource(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<20>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> SlcState::Builder::disownLastReceivedSource() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<20>() * ::capnp::POINTERS));
}

inline float SlcState::Reader::getLastReceivedAdjustedLimit() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<32>() * ::capnp::ELEMENTS);
}

inline float SlcState::Builder::getLastReceivedAdjustedLimit() {
  return _builder.getDataField<float>(
      ::capnp::bounded<32>() * ::capnp::ELEMENTS);
}
inline void SlcState::Builder::setLastReceivedAdjustedLimit(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<32>() * ::capnp::ELEMENTS, value);
}

inline bool SlcState::SourceReading::Reader::hasSource() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool SlcState::SourceReading::Builder::hasSource() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader SlcState::SourceReading::Reader::getSource() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder SlcState::SourceReading::Builder::getSource() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void SlcState::SourceReading::Builder::setSource( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder SlcState::SourceReading::Builder::initSource(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void SlcState::SourceReading::Builder::adoptSource(
    ::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> SlcState::SourceReading::Builder::disownSource() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline bool SlcState::SourceReading::Reader::getEnabled() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline bool SlcState::SourceReading::Builder::getEnabled() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void SlcState::SourceReading::Builder::setEnabled(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool SlcState::SourceReading::Reader::hasObservationKind() const {
  return !_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline bool SlcState::SourceReading::Builder::hasObservationKind() {
  return !_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader SlcState::SourceReading::Reader::getObservationKind() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder SlcState::SourceReading::Builder::getObservationKind() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline void SlcState::SourceReading::Builder::setObservationKind( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder SlcState::SourceReading::Builder::initObservationKind(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), size);
}
inline void SlcState::SourceReading::Builder::adoptObservationKind(
    ::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> SlcState::SourceReading::Builder::disownObservationKind() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}

inline float SlcState::SourceReading::Reader::getSpeedLimit() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline float SlcState::SourceReading::Builder::getSpeedLimit() {
  return _builder.getDataField<float>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void SlcState::SourceReading::Builder::setSpeedLimit(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline  ::uint16_t SlcState::SwitchbackModeState::Reader::getVersion() const {
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline  ::uint16_t SlcState::SwitchbackModeState::Builder::getVersion() {
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void SlcState::SwitchbackModeState::Builder::setVersion( ::uint16_t value) {
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool SlcState::SwitchbackModeState::Reader::hasSessionId() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool SlcState::SwitchbackModeState::Builder::hasSessionId() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader SlcState::SwitchbackModeState::Reader::getSessionId() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder SlcState::SwitchbackModeState::Builder::getSessionId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void SlcState::SwitchbackModeState::Builder::setSessionId( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder SlcState::SwitchbackModeState::Builder::initSessionId(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void SlcState::SwitchbackModeState::Builder::adoptSessionId(
    ::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> SlcState::SwitchbackModeState::Builder::disownSessionId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline  ::uint64_t SlcState::SwitchbackModeState::Reader::getSequence() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcState::SwitchbackModeState::Builder::getSequence() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void SlcState::SwitchbackModeState::Builder::setSequence( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t SlcState::SwitchbackModeState::Reader::getObservedMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcState::SwitchbackModeState::Builder::getObservedMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void SlcState::SwitchbackModeState::Builder::setObservedMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t SlcState::SwitchbackModeState::Reader::getValidUntilMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcState::SwitchbackModeState::Builder::getValidUntilMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}
inline void SlcState::SwitchbackModeState::Builder::setValidUntilMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t SlcState::SwitchbackModeState::Reader::getDriveStartMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcState::SwitchbackModeState::Builder::getDriveStartMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}
inline void SlcState::SwitchbackModeState::Builder::setDriveStartMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS, value);
}

inline bool SlcState::SwitchbackModeState::Reader::getRequested() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS);
}

inline bool SlcState::SwitchbackModeState::Builder::getRequested() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS);
}
inline void SlcState::SwitchbackModeState::Builder::setRequested(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS, value);
}

inline bool SlcState::SwitchbackModeState::Reader::getEffective() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<17>() * ::capnp::ELEMENTS);
}

inline bool SlcState::SwitchbackModeState::Builder::getEffective() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<17>() * ::capnp::ELEMENTS);
}
inline void SlcState::SwitchbackModeState::Builder::setEffective(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<17>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t SlcState::SwitchbackModeState::Reader::getSourceCarControlMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcState::SwitchbackModeState::Builder::getSourceCarControlMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}
inline void SlcState::SwitchbackModeState::Builder::setSourceCarControlMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS, value);
}

inline  ::uint16_t SlcState::TrafficModeState::Reader::getVersion() const {
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline  ::uint16_t SlcState::TrafficModeState::Builder::getVersion() {
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void SlcState::TrafficModeState::Builder::setVersion( ::uint16_t value) {
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool SlcState::TrafficModeState::Reader::hasSessionId() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool SlcState::TrafficModeState::Builder::hasSessionId() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader SlcState::TrafficModeState::Reader::getSessionId() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder SlcState::TrafficModeState::Builder::getSessionId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void SlcState::TrafficModeState::Builder::setSessionId( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder SlcState::TrafficModeState::Builder::initSessionId(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void SlcState::TrafficModeState::Builder::adoptSessionId(
    ::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> SlcState::TrafficModeState::Builder::disownSessionId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline  ::uint64_t SlcState::TrafficModeState::Reader::getSequence() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcState::TrafficModeState::Builder::getSequence() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void SlcState::TrafficModeState::Builder::setSequence( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t SlcState::TrafficModeState::Reader::getObservedMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcState::TrafficModeState::Builder::getObservedMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void SlcState::TrafficModeState::Builder::setObservedMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t SlcState::TrafficModeState::Reader::getValidUntilMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcState::TrafficModeState::Builder::getValidUntilMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}
inline void SlcState::TrafficModeState::Builder::setValidUntilMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t SlcState::TrafficModeState::Reader::getDriveStartMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcState::TrafficModeState::Builder::getDriveStartMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}
inline void SlcState::TrafficModeState::Builder::setDriveStartMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t SlcState::TrafficModeState::Reader::getSourceEpoch() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcState::TrafficModeState::Builder::getSourceEpoch() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}
inline void SlcState::TrafficModeState::Builder::setSourceEpoch( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t SlcState::TrafficModeState::Reader::getSourceBootTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcState::TrafficModeState::Builder::getSourceBootTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS);
}
inline void SlcState::TrafficModeState::Builder::setSourceBootTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS, value);
}

inline bool SlcState::TrafficModeState::Reader::getAccepted() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS);
}

inline bool SlcState::TrafficModeState::Builder::getAccepted() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS);
}
inline void SlcState::TrafficModeState::Builder::setAccepted(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS, value);
}

inline bool SlcState::TrafficModeState::Reader::getEffective() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<17>() * ::capnp::ELEMENTS);
}

inline bool SlcState::TrafficModeState::Builder::getEffective() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<17>() * ::capnp::ELEMENTS);
}
inline void SlcState::TrafficModeState::Builder::setEffective(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<17>() * ::capnp::ELEMENTS, value);
}

inline bool SlcState::TrafficModeState::Reader::hasReason() const {
  return !_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline bool SlcState::TrafficModeState::Builder::hasReason() {
  return !_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader SlcState::TrafficModeState::Reader::getReason() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder SlcState::TrafficModeState::Builder::getReason() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline void SlcState::TrafficModeState::Builder::setReason( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder SlcState::TrafficModeState::Builder::initReason(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), size);
}
inline void SlcState::TrafficModeState::Builder::adoptReason(
    ::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> SlcState::TrafficModeState::Builder::disownReason() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}

inline bool SlcState::TrafficModeState::Reader::hasSettingsFingerprint() const {
  return !_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline bool SlcState::TrafficModeState::Builder::hasSettingsFingerprint() {
  return !_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader SlcState::TrafficModeState::Reader::getSettingsFingerprint() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder SlcState::TrafficModeState::Builder::getSettingsFingerprint() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline void SlcState::TrafficModeState::Builder::setSettingsFingerprint( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder SlcState::TrafficModeState::Builder::initSettingsFingerprint(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), size);
}
inline void SlcState::TrafficModeState::Builder::adoptSettingsFingerprint(
    ::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> SlcState::TrafficModeState::Builder::disownSettingsFingerprint() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}

inline bool SlcState::TrafficModeState::Reader::hasButtonMapFingerprint() const {
  return !_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline bool SlcState::TrafficModeState::Builder::hasButtonMapFingerprint() {
  return !_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader SlcState::TrafficModeState::Reader::getButtonMapFingerprint() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder SlcState::TrafficModeState::Builder::getButtonMapFingerprint() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline void SlcState::TrafficModeState::Builder::setButtonMapFingerprint( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder SlcState::TrafficModeState::Builder::initButtonMapFingerprint(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), size);
}
inline void SlcState::TrafficModeState::Builder::adoptButtonMapFingerprint(
    ::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> SlcState::TrafficModeState::Builder::disownButtonMapFingerprint() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}

inline bool SlcState::TrafficModeState::Reader::getProfileTargetReady() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<18>() * ::capnp::ELEMENTS);
}

inline bool SlcState::TrafficModeState::Builder::getProfileTargetReady() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<18>() * ::capnp::ELEMENTS);
}
inline void SlcState::TrafficModeState::Builder::setProfileTargetReady(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<18>() * ::capnp::ELEMENTS, value);
}

inline bool SlcState::TrafficModeState::Reader::hasProfileReason() const {
  return !_reader.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS).isNull();
}
inline bool SlcState::TrafficModeState::Builder::hasProfileReason() {
  return !_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader SlcState::TrafficModeState::Reader::getProfileReason() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder SlcState::TrafficModeState::Builder::getProfileReason() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}
inline void SlcState::TrafficModeState::Builder::setProfileReason( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder SlcState::TrafficModeState::Builder::initProfileReason(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), size);
}
inline void SlcState::TrafficModeState::Builder::adoptProfileReason(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> SlcState::TrafficModeState::Builder::disownProfileReason() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}

inline bool SlcState::TrafficModeState::Reader::getControllerSource() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<19>() * ::capnp::ELEMENTS);
}

inline bool SlcState::TrafficModeState::Builder::getControllerSource() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<19>() * ::capnp::ELEMENTS);
}
inline void SlcState::TrafficModeState::Builder::setControllerSource(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<19>() * ::capnp::ELEMENTS, value);
}

inline  ::uint16_t SlcState::CurveState::Reader::getVersion() const {
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline  ::uint16_t SlcState::CurveState::Builder::getVersion() {
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void SlcState::CurveState::Builder::setVersion( ::uint16_t value) {
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool SlcState::CurveState::Reader::hasSessionId() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool SlcState::CurveState::Builder::hasSessionId() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader SlcState::CurveState::Reader::getSessionId() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder SlcState::CurveState::Builder::getSessionId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void SlcState::CurveState::Builder::setSessionId( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder SlcState::CurveState::Builder::initSessionId(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void SlcState::CurveState::Builder::adoptSessionId(
    ::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> SlcState::CurveState::Builder::disownSessionId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline  ::uint64_t SlcState::CurveState::Reader::getSequence() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcState::CurveState::Builder::getSequence() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void SlcState::CurveState::Builder::setSequence( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t SlcState::CurveState::Reader::getObservedMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcState::CurveState::Builder::getObservedMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void SlcState::CurveState::Builder::setObservedMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t SlcState::CurveState::Reader::getValidUntilMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcState::CurveState::Builder::getValidUntilMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}
inline void SlcState::CurveState::Builder::setValidUntilMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t SlcState::CurveState::Reader::getModelMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcState::CurveState::Builder::getModelMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}
inline void SlcState::CurveState::Builder::setModelMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS, value);
}

inline bool SlcState::CurveState::Reader::getConfigured() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS);
}

inline bool SlcState::CurveState::Builder::getConfigured() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS);
}
inline void SlcState::CurveState::Builder::setConfigured(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS, value);
}

inline bool SlcState::CurveState::Reader::getDocumentValid() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<17>() * ::capnp::ELEMENTS);
}

inline bool SlcState::CurveState::Builder::getDocumentValid() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<17>() * ::capnp::ELEMENTS);
}
inline void SlcState::CurveState::Builder::setDocumentValid(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<17>() * ::capnp::ELEMENTS, value);
}

inline bool SlcState::CurveState::Reader::getHasCandidate() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<18>() * ::capnp::ELEMENTS);
}

inline bool SlcState::CurveState::Builder::getHasCandidate() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<18>() * ::capnp::ELEMENTS);
}
inline void SlcState::CurveState::Builder::setHasCandidate(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<18>() * ::capnp::ELEMENTS, value);
}

inline float SlcState::CurveState::Reader::getCandidateMps() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline float SlcState::CurveState::Builder::getCandidateMps() {
  return _builder.getDataField<float>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void SlcState::CurveState::Builder::setCandidateMps(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline bool SlcState::CurveState::Reader::getHasCeiling() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<19>() * ::capnp::ELEMENTS);
}

inline bool SlcState::CurveState::Builder::getHasCeiling() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<19>() * ::capnp::ELEMENTS);
}
inline void SlcState::CurveState::Builder::setHasCeiling(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<19>() * ::capnp::ELEMENTS, value);
}

inline float SlcState::CurveState::Reader::getCeilingMps() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<10>() * ::capnp::ELEMENTS);
}

inline float SlcState::CurveState::Builder::getCeilingMps() {
  return _builder.getDataField<float>(
      ::capnp::bounded<10>() * ::capnp::ELEMENTS);
}
inline void SlcState::CurveState::Builder::setCeilingMps(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<10>() * ::capnp::ELEMENTS, value);
}

inline bool SlcState::CurveState::Reader::getApplied() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<20>() * ::capnp::ELEMENTS);
}

inline bool SlcState::CurveState::Builder::getApplied() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<20>() * ::capnp::ELEMENTS);
}
inline void SlcState::CurveState::Builder::setApplied(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<20>() * ::capnp::ELEMENTS, value);
}

inline bool SlcState::CurveState::Reader::getControlling() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<21>() * ::capnp::ELEMENTS);
}

inline bool SlcState::CurveState::Builder::getControlling() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<21>() * ::capnp::ELEMENTS);
}
inline void SlcState::CurveState::Builder::setControlling(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<21>() * ::capnp::ELEMENTS, value);
}

inline bool SlcState::CurveState::Reader::getTraining() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<22>() * ::capnp::ELEMENTS);
}

inline bool SlcState::CurveState::Builder::getTraining() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<22>() * ::capnp::ELEMENTS);
}
inline void SlcState::CurveState::Builder::setTraining(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<22>() * ::capnp::ELEMENTS, value);
}

inline float SlcState::CurveState::Reader::getCalibrationProgress() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<11>() * ::capnp::ELEMENTS);
}

inline float SlcState::CurveState::Builder::getCalibrationProgress() {
  return _builder.getDataField<float>(
      ::capnp::bounded<11>() * ::capnp::ELEMENTS);
}
inline void SlcState::CurveState::Builder::setCalibrationProgress(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<11>() * ::capnp::ELEMENTS, value);
}

inline float SlcState::CurveState::Reader::getComfortAccel() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<12>() * ::capnp::ELEMENTS);
}

inline float SlcState::CurveState::Builder::getComfortAccel() {
  return _builder.getDataField<float>(
      ::capnp::bounded<12>() * ::capnp::ELEMENTS);
}
inline void SlcState::CurveState::Builder::setComfortAccel(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<12>() * ::capnp::ELEMENTS, value);
}

inline float SlcState::CurveState::Reader::getBindingDistance() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<13>() * ::capnp::ELEMENTS);
}

inline float SlcState::CurveState::Builder::getBindingDistance() {
  return _builder.getDataField<float>(
      ::capnp::bounded<13>() * ::capnp::ELEMENTS);
}
inline void SlcState::CurveState::Builder::setBindingDistance(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<13>() * ::capnp::ELEMENTS, value);
}

inline bool SlcState::CurveState::Reader::hasReason() const {
  return !_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline bool SlcState::CurveState::Builder::hasReason() {
  return !_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader SlcState::CurveState::Reader::getReason() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder SlcState::CurveState::Builder::getReason() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline void SlcState::CurveState::Builder::setReason( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder SlcState::CurveState::Builder::initReason(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), size);
}
inline void SlcState::CurveState::Builder::adoptReason(
    ::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> SlcState::CurveState::Builder::disownReason() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}

inline bool SlcState::CurveState::Reader::hasPlannerStatus() const {
  return !_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline bool SlcState::CurveState::Builder::hasPlannerStatus() {
  return !_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader SlcState::CurveState::Reader::getPlannerStatus() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder SlcState::CurveState::Builder::getPlannerStatus() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline void SlcState::CurveState::Builder::setPlannerStatus( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder SlcState::CurveState::Builder::initPlannerStatus(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), size);
}
inline void SlcState::CurveState::Builder::adoptPlannerStatus(
    ::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> SlcState::CurveState::Builder::disownPlannerStatus() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}

inline bool SlcState::CurveState::Reader::hasPersistenceStatus() const {
  return !_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline bool SlcState::CurveState::Builder::hasPersistenceStatus() {
  return !_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader SlcState::CurveState::Reader::getPersistenceStatus() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder SlcState::CurveState::Builder::getPersistenceStatus() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline void SlcState::CurveState::Builder::setPersistenceStatus( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder SlcState::CurveState::Builder::initPersistenceStatus(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), size);
}
inline void SlcState::CurveState::Builder::adoptPersistenceStatus(
    ::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> SlcState::CurveState::Builder::disownPersistenceStatus() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}

inline bool SlcState::CurveState::Reader::getGlow() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<23>() * ::capnp::ELEMENTS);
}

inline bool SlcState::CurveState::Builder::getGlow() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<23>() * ::capnp::ELEMENTS);
}
inline void SlcState::CurveState::Builder::setGlow(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<23>() * ::capnp::ELEMENTS, value);
}

inline bool SlcState::CurveState::Reader::getCurveOnly() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<24>() * ::capnp::ELEMENTS);
}

inline bool SlcState::CurveState::Builder::getCurveOnly() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<24>() * ::capnp::ELEMENTS);
}
inline void SlcState::CurveState::Builder::setCurveOnly(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<24>() * ::capnp::ELEMENTS, value);
}

inline bool SlcState::CurveState::Reader::getHasRoadCurvature() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<25>() * ::capnp::ELEMENTS);
}

inline bool SlcState::CurveState::Builder::getHasRoadCurvature() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<25>() * ::capnp::ELEMENTS);
}
inline void SlcState::CurveState::Builder::setHasRoadCurvature(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<25>() * ::capnp::ELEMENTS, value);
}

inline float SlcState::CurveState::Reader::getRoadCurvature() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<14>() * ::capnp::ELEMENTS);
}

inline float SlcState::CurveState::Builder::getRoadCurvature() {
  return _builder.getDataField<float>(
      ::capnp::bounded<14>() * ::capnp::ELEMENTS);
}
inline void SlcState::CurveState::Builder::setRoadCurvature(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<14>() * ::capnp::ELEMENTS, value);
}

inline  ::uint16_t SlcState::ConditionalModeState::Reader::getVersion() const {
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline  ::uint16_t SlcState::ConditionalModeState::Builder::getVersion() {
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void SlcState::ConditionalModeState::Builder::setVersion( ::uint16_t value) {
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool SlcState::ConditionalModeState::Reader::hasSessionId() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool SlcState::ConditionalModeState::Builder::hasSessionId() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader SlcState::ConditionalModeState::Reader::getSessionId() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder SlcState::ConditionalModeState::Builder::getSessionId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void SlcState::ConditionalModeState::Builder::setSessionId( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder SlcState::ConditionalModeState::Builder::initSessionId(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void SlcState::ConditionalModeState::Builder::adoptSessionId(
    ::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> SlcState::ConditionalModeState::Builder::disownSessionId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline  ::uint64_t SlcState::ConditionalModeState::Reader::getSequence() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcState::ConditionalModeState::Builder::getSequence() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void SlcState::ConditionalModeState::Builder::setSequence( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t SlcState::ConditionalModeState::Reader::getObservedMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcState::ConditionalModeState::Builder::getObservedMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void SlcState::ConditionalModeState::Builder::setObservedMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t SlcState::ConditionalModeState::Reader::getValidUntilMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcState::ConditionalModeState::Builder::getValidUntilMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}
inline void SlcState::ConditionalModeState::Builder::setValidUntilMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t SlcState::ConditionalModeState::Reader::getDriveStartMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcState::ConditionalModeState::Builder::getDriveStartMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}
inline void SlcState::ConditionalModeState::Builder::setDriveStartMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t SlcState::ConditionalModeState::Reader::getModelMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcState::ConditionalModeState::Builder::getModelMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}
inline void SlcState::ConditionalModeState::Builder::setModelMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t SlcState::ConditionalModeState::Reader::getCarStateMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcState::ConditionalModeState::Builder::getCarStateMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS);
}
inline void SlcState::ConditionalModeState::Builder::setCarStateMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t SlcState::ConditionalModeState::Reader::getSettingsRevision() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<7>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcState::ConditionalModeState::Builder::getSettingsRevision() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<7>() * ::capnp::ELEMENTS);
}
inline void SlcState::ConditionalModeState::Builder::setSettingsRevision( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<7>() * ::capnp::ELEMENTS, value);
}

inline bool SlcState::ConditionalModeState::Reader::hasSettingsFingerprint() const {
  return !_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline bool SlcState::ConditionalModeState::Builder::hasSettingsFingerprint() {
  return !_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader SlcState::ConditionalModeState::Reader::getSettingsFingerprint() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder SlcState::ConditionalModeState::Builder::getSettingsFingerprint() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline void SlcState::ConditionalModeState::Builder::setSettingsFingerprint( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder SlcState::ConditionalModeState::Builder::initSettingsFingerprint(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), size);
}
inline void SlcState::ConditionalModeState::Builder::adoptSettingsFingerprint(
    ::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> SlcState::ConditionalModeState::Builder::disownSettingsFingerprint() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}

inline  ::cereal::SlcState::ConditionalModeState::Choice SlcState::ConditionalModeState::Reader::getChoice() const {
  return _reader.getDataField< ::cereal::SlcState::ConditionalModeState::Choice>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline  ::cereal::SlcState::ConditionalModeState::Choice SlcState::ConditionalModeState::Builder::getChoice() {
  return _builder.getDataField< ::cereal::SlcState::ConditionalModeState::Choice>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void SlcState::ConditionalModeState::Builder::setChoice( ::cereal::SlcState::ConditionalModeState::Choice value) {
  _builder.setDataField< ::cereal::SlcState::ConditionalModeState::Choice>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline bool SlcState::ConditionalModeState::Reader::getHasOverride() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<32>() * ::capnp::ELEMENTS);
}

inline bool SlcState::ConditionalModeState::Builder::getHasOverride() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<32>() * ::capnp::ELEMENTS);
}
inline void SlcState::ConditionalModeState::Builder::setHasOverride(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<32>() * ::capnp::ELEMENTS, value);
}

inline bool SlcState::ConditionalModeState::Reader::getExperimental() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<33>() * ::capnp::ELEMENTS);
}

inline bool SlcState::ConditionalModeState::Builder::getExperimental() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<33>() * ::capnp::ELEMENTS);
}
inline void SlcState::ConditionalModeState::Builder::setExperimental(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<33>() * ::capnp::ELEMENTS, value);
}

inline bool SlcState::ConditionalModeState::Reader::hasStatus() const {
  return !_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline bool SlcState::ConditionalModeState::Builder::hasStatus() {
  return !_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader SlcState::ConditionalModeState::Reader::getStatus() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder SlcState::ConditionalModeState::Builder::getStatus() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline void SlcState::ConditionalModeState::Builder::setStatus( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder SlcState::ConditionalModeState::Builder::initStatus(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), size);
}
inline void SlcState::ConditionalModeState::Builder::adoptStatus(
    ::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> SlcState::ConditionalModeState::Builder::disownStatus() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}

inline bool SlcState::ConditionalModeState::Reader::hasReason() const {
  return !_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline bool SlcState::ConditionalModeState::Builder::hasReason() {
  return !_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader SlcState::ConditionalModeState::Reader::getReason() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder SlcState::ConditionalModeState::Builder::getReason() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline void SlcState::ConditionalModeState::Builder::setReason( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder SlcState::ConditionalModeState::Builder::initReason(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), size);
}
inline void SlcState::ConditionalModeState::Builder::adoptReason(
    ::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> SlcState::ConditionalModeState::Builder::disownReason() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}

inline  ::uint16_t SlcState::ConditionalModeState::Reader::getStatusCode() const {
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}

inline  ::uint16_t SlcState::ConditionalModeState::Builder::getStatusCode() {
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}
inline void SlcState::ConditionalModeState::Builder::setStatusCode( ::uint16_t value) {
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS, value);
}

inline bool SlcAction::Reader::hasSessionId() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool SlcAction::Builder::hasSessionId() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader SlcAction::Reader::getSessionId() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder SlcAction::Builder::getSessionId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void SlcAction::Builder::setSessionId( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder SlcAction::Builder::initSessionId(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void SlcAction::Builder::adoptSessionId(
    ::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> SlcAction::Builder::disownSessionId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline  ::uint64_t SlcAction::Reader::getSequenceId() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcAction::Builder::getSequenceId() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void SlcAction::Builder::setSequenceId( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t SlcAction::Reader::getDecisionId() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcAction::Builder::getDecisionId() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void SlcAction::Builder::setDecisionId( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t SlcAction::Reader::getPresentationId() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcAction::Builder::getPresentationId() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void SlcAction::Builder::setPresentationId( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline  ::cereal::SlcAction::Kind SlcAction::Reader::getKind() const {
  return _reader.getDataField< ::cereal::SlcAction::Kind>(
      ::capnp::bounded<12>() * ::capnp::ELEMENTS);
}

inline  ::cereal::SlcAction::Kind SlcAction::Builder::getKind() {
  return _builder.getDataField< ::cereal::SlcAction::Kind>(
      ::capnp::bounded<12>() * ::capnp::ELEMENTS);
}
inline void SlcAction::Builder::setKind( ::cereal::SlcAction::Kind value) {
  _builder.setDataField< ::cereal::SlcAction::Kind>(
      ::capnp::bounded<12>() * ::capnp::ELEMENTS, value);
}

inline bool SlcAction::Reader::hasConditionalManual() const {
  return !_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline bool SlcAction::Builder::hasConditionalManual() {
  return !_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline  ::cereal::SlcAction::ConditionalManualAction::Reader SlcAction::Reader::getConditionalManual() const {
  return ::capnp::_::PointerHelpers< ::cereal::SlcAction::ConditionalManualAction>::get(_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline  ::cereal::SlcAction::ConditionalManualAction::Builder SlcAction::Builder::getConditionalManual() {
  return ::capnp::_::PointerHelpers< ::cereal::SlcAction::ConditionalManualAction>::get(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
#if !CAPNP_LITE
inline  ::cereal::SlcAction::ConditionalManualAction::Pipeline SlcAction::Pipeline::getConditionalManual() {
  return  ::cereal::SlcAction::ConditionalManualAction::Pipeline(_typeless.getPointerField(1));
}
#endif  // !CAPNP_LITE
inline void SlcAction::Builder::setConditionalManual( ::cereal::SlcAction::ConditionalManualAction::Reader value) {
  ::capnp::_::PointerHelpers< ::cereal::SlcAction::ConditionalManualAction>::set(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), value);
}
inline  ::cereal::SlcAction::ConditionalManualAction::Builder SlcAction::Builder::initConditionalManual() {
  return ::capnp::_::PointerHelpers< ::cereal::SlcAction::ConditionalManualAction>::init(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline void SlcAction::Builder::adoptConditionalManual(
    ::capnp::Orphan< ::cereal::SlcAction::ConditionalManualAction>&& value) {
  ::capnp::_::PointerHelpers< ::cereal::SlcAction::ConditionalManualAction>::adopt(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::cereal::SlcAction::ConditionalManualAction> SlcAction::Builder::disownConditionalManual() {
  return ::capnp::_::PointerHelpers< ::cereal::SlcAction::ConditionalManualAction>::disown(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}

inline bool SlcAction::Reader::hasControllerCruise() const {
  return !_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline bool SlcAction::Builder::hasControllerCruise() {
  return !_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline  ::cereal::SlcAction::ControllerCruiseAction::Reader SlcAction::Reader::getControllerCruise() const {
  return ::capnp::_::PointerHelpers< ::cereal::SlcAction::ControllerCruiseAction>::get(_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline  ::cereal::SlcAction::ControllerCruiseAction::Builder SlcAction::Builder::getControllerCruise() {
  return ::capnp::_::PointerHelpers< ::cereal::SlcAction::ControllerCruiseAction>::get(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
#if !CAPNP_LITE
inline  ::cereal::SlcAction::ControllerCruiseAction::Pipeline SlcAction::Pipeline::getControllerCruise() {
  return  ::cereal::SlcAction::ControllerCruiseAction::Pipeline(_typeless.getPointerField(2));
}
#endif  // !CAPNP_LITE
inline void SlcAction::Builder::setControllerCruise( ::cereal::SlcAction::ControllerCruiseAction::Reader value) {
  ::capnp::_::PointerHelpers< ::cereal::SlcAction::ControllerCruiseAction>::set(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), value);
}
inline  ::cereal::SlcAction::ControllerCruiseAction::Builder SlcAction::Builder::initControllerCruise() {
  return ::capnp::_::PointerHelpers< ::cereal::SlcAction::ControllerCruiseAction>::init(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline void SlcAction::Builder::adoptControllerCruise(
    ::capnp::Orphan< ::cereal::SlcAction::ControllerCruiseAction>&& value) {
  ::capnp::_::PointerHelpers< ::cereal::SlcAction::ControllerCruiseAction>::adopt(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::cereal::SlcAction::ControllerCruiseAction> SlcAction::Builder::disownControllerCruise() {
  return ::capnp::_::PointerHelpers< ::cereal::SlcAction::ControllerCruiseAction>::disown(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}

inline bool SlcAction::Reader::hasControllerMode() const {
  return !_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline bool SlcAction::Builder::hasControllerMode() {
  return !_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline  ::cereal::SlcAction::ControllerCruiseAction::Reader SlcAction::Reader::getControllerMode() const {
  return ::capnp::_::PointerHelpers< ::cereal::SlcAction::ControllerCruiseAction>::get(_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline  ::cereal::SlcAction::ControllerCruiseAction::Builder SlcAction::Builder::getControllerMode() {
  return ::capnp::_::PointerHelpers< ::cereal::SlcAction::ControllerCruiseAction>::get(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
#if !CAPNP_LITE
inline  ::cereal::SlcAction::ControllerCruiseAction::Pipeline SlcAction::Pipeline::getControllerMode() {
  return  ::cereal::SlcAction::ControllerCruiseAction::Pipeline(_typeless.getPointerField(3));
}
#endif  // !CAPNP_LITE
inline void SlcAction::Builder::setControllerMode( ::cereal::SlcAction::ControllerCruiseAction::Reader value) {
  ::capnp::_::PointerHelpers< ::cereal::SlcAction::ControllerCruiseAction>::set(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), value);
}
inline  ::cereal::SlcAction::ControllerCruiseAction::Builder SlcAction::Builder::initControllerMode() {
  return ::capnp::_::PointerHelpers< ::cereal::SlcAction::ControllerCruiseAction>::init(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline void SlcAction::Builder::adoptControllerMode(
    ::capnp::Orphan< ::cereal::SlcAction::ControllerCruiseAction>&& value) {
  ::capnp::_::PointerHelpers< ::cereal::SlcAction::ControllerCruiseAction>::adopt(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::cereal::SlcAction::ControllerCruiseAction> SlcAction::Builder::disownControllerMode() {
  return ::capnp::_::PointerHelpers< ::cereal::SlcAction::ControllerCruiseAction>::disown(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}

inline  ::uint16_t SlcAction::ControllerCruiseAction::Reader::getVersion() const {
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline  ::uint16_t SlcAction::ControllerCruiseAction::Builder::getVersion() {
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void SlcAction::ControllerCruiseAction::Builder::setVersion( ::uint16_t value) {
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool SlcAction::ControllerCruiseAction::Reader::hasSessionId() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool SlcAction::ControllerCruiseAction::Builder::hasSessionId() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader SlcAction::ControllerCruiseAction::Reader::getSessionId() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder SlcAction::ControllerCruiseAction::Builder::getSessionId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void SlcAction::ControllerCruiseAction::Builder::setSessionId( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder SlcAction::ControllerCruiseAction::Builder::initSessionId(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void SlcAction::ControllerCruiseAction::Builder::adoptSessionId(
    ::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> SlcAction::ControllerCruiseAction::Builder::disownSessionId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline  ::uint64_t SlcAction::ControllerCruiseAction::Reader::getSequence() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcAction::ControllerCruiseAction::Builder::getSequence() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void SlcAction::ControllerCruiseAction::Builder::setSequence( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t SlcAction::ControllerCruiseAction::Reader::getObservedMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcAction::ControllerCruiseAction::Builder::getObservedMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void SlcAction::ControllerCruiseAction::Builder::setObservedMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t SlcAction::ControllerCruiseAction::Reader::getValidUntilMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcAction::ControllerCruiseAction::Builder::getValidUntilMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}
inline void SlcAction::ControllerCruiseAction::Builder::setValidUntilMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t SlcAction::ControllerCruiseAction::Reader::getDriveStartMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcAction::ControllerCruiseAction::Builder::getDriveStartMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}
inline void SlcAction::ControllerCruiseAction::Builder::setDriveStartMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS, value);
}

inline bool SlcAction::ControllerCruiseAction::Reader::hasCarFingerprint() const {
  return !_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline bool SlcAction::ControllerCruiseAction::Builder::hasCarFingerprint() {
  return !_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader SlcAction::ControllerCruiseAction::Reader::getCarFingerprint() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder SlcAction::ControllerCruiseAction::Builder::getCarFingerprint() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline void SlcAction::ControllerCruiseAction::Builder::setCarFingerprint( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder SlcAction::ControllerCruiseAction::Builder::initCarFingerprint(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), size);
}
inline void SlcAction::ControllerCruiseAction::Builder::adoptCarFingerprint(
    ::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> SlcAction::ControllerCruiseAction::Builder::disownCarFingerprint() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}

inline  ::uint64_t SlcAction::ControllerCruiseAction::Reader::getSourceCarControlMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcAction::ControllerCruiseAction::Builder::getSourceCarControlMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}
inline void SlcAction::ControllerCruiseAction::Builder::setSourceCarControlMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS, value);
}

inline  ::uint8_t SlcAction::ControllerCruiseAction::Reader::getActionCode() const {
  return _reader.getDataField< ::uint8_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline  ::uint8_t SlcAction::ControllerCruiseAction::Builder::getActionCode() {
  return _builder.getDataField< ::uint8_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void SlcAction::ControllerCruiseAction::Builder::setActionCode( ::uint8_t value) {
  _builder.setDataField< ::uint8_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline bool SlcAction::ControllerCruiseAction::Reader::hasButtonKey() const {
  return !_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline bool SlcAction::ControllerCruiseAction::Builder::hasButtonKey() {
  return !_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader SlcAction::ControllerCruiseAction::Reader::getButtonKey() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder SlcAction::ControllerCruiseAction::Builder::getButtonKey() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline void SlcAction::ControllerCruiseAction::Builder::setButtonKey( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder SlcAction::ControllerCruiseAction::Builder::initButtonKey(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), size);
}
inline void SlcAction::ControllerCruiseAction::Builder::adoptButtonKey(
    ::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> SlcAction::ControllerCruiseAction::Builder::disownButtonKey() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}

inline  ::uint64_t SlcAction::ControllerCruiseAction::Reader::getSourceCarStateMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcAction::ControllerCruiseAction::Builder::getSourceCarStateMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS);
}
inline void SlcAction::ControllerCruiseAction::Builder::setSourceCarStateMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS, value);
}

inline bool SlcAction::ControllerCruiseAction::Reader::hasCarParamsFingerprint() const {
  return !_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline bool SlcAction::ControllerCruiseAction::Builder::hasCarParamsFingerprint() {
  return !_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader SlcAction::ControllerCruiseAction::Reader::getCarParamsFingerprint() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder SlcAction::ControllerCruiseAction::Builder::getCarParamsFingerprint() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline void SlcAction::ControllerCruiseAction::Builder::setCarParamsFingerprint( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder SlcAction::ControllerCruiseAction::Builder::initCarParamsFingerprint(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), size);
}
inline void SlcAction::ControllerCruiseAction::Builder::adoptCarParamsFingerprint(
    ::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> SlcAction::ControllerCruiseAction::Builder::disownCarParamsFingerprint() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}

inline float SlcAction::ControllerCruiseAction::Reader::getTargetSpeedMps() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline float SlcAction::ControllerCruiseAction::Builder::getTargetSpeedMps() {
  return _builder.getDataField<float>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void SlcAction::ControllerCruiseAction::Builder::setTargetSpeedMps(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline  ::uint16_t SlcAction::ConditionalManualAction::Reader::getVersion() const {
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline  ::uint16_t SlcAction::ConditionalManualAction::Builder::getVersion() {
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void SlcAction::ConditionalManualAction::Builder::setVersion( ::uint16_t value) {
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool SlcAction::ConditionalManualAction::Reader::hasSessionId() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool SlcAction::ConditionalManualAction::Builder::hasSessionId() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader SlcAction::ConditionalManualAction::Reader::getSessionId() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder SlcAction::ConditionalManualAction::Builder::getSessionId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void SlcAction::ConditionalManualAction::Builder::setSessionId( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder SlcAction::ConditionalManualAction::Builder::initSessionId(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void SlcAction::ConditionalManualAction::Builder::adoptSessionId(
    ::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> SlcAction::ConditionalManualAction::Builder::disownSessionId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline  ::uint64_t SlcAction::ConditionalManualAction::Reader::getSequence() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcAction::ConditionalManualAction::Builder::getSequence() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void SlcAction::ConditionalManualAction::Builder::setSequence( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t SlcAction::ConditionalManualAction::Reader::getObservedMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcAction::ConditionalManualAction::Builder::getObservedMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void SlcAction::ConditionalManualAction::Builder::setObservedMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t SlcAction::ConditionalManualAction::Reader::getValidUntilMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcAction::ConditionalManualAction::Builder::getValidUntilMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}
inline void SlcAction::ConditionalManualAction::Builder::setValidUntilMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t SlcAction::ConditionalManualAction::Reader::getDriveStartMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcAction::ConditionalManualAction::Builder::getDriveStartMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}
inline void SlcAction::ConditionalManualAction::Builder::setDriveStartMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS, value);
}

inline bool SlcAction::ConditionalManualAction::Reader::hasSettingsFingerprint() const {
  return !_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline bool SlcAction::ConditionalManualAction::Builder::hasSettingsFingerprint() {
  return !_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader SlcAction::ConditionalManualAction::Reader::getSettingsFingerprint() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder SlcAction::ConditionalManualAction::Builder::getSettingsFingerprint() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline void SlcAction::ConditionalManualAction::Builder::setSettingsFingerprint( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder SlcAction::ConditionalManualAction::Builder::initSettingsFingerprint(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), size);
}
inline void SlcAction::ConditionalManualAction::Builder::adoptSettingsFingerprint(
    ::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> SlcAction::ConditionalManualAction::Builder::disownSettingsFingerprint() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}

inline  ::cereal::SlcState::ConditionalModeState::Choice SlcAction::ConditionalManualAction::Reader::getChoice() const {
  return _reader.getDataField< ::cereal::SlcState::ConditionalModeState::Choice>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline  ::cereal::SlcState::ConditionalModeState::Choice SlcAction::ConditionalManualAction::Builder::getChoice() {
  return _builder.getDataField< ::cereal::SlcState::ConditionalModeState::Choice>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void SlcAction::ConditionalManualAction::Builder::setChoice( ::cereal::SlcState::ConditionalModeState::Choice value) {
  _builder.setDataField< ::cereal::SlcState::ConditionalModeState::Choice>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline bool SlcAction::ConditionalManualAction::Reader::hasPlannerSessionId() const {
  return !_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline bool SlcAction::ConditionalManualAction::Builder::hasPlannerSessionId() {
  return !_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader SlcAction::ConditionalManualAction::Reader::getPlannerSessionId() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder SlcAction::ConditionalManualAction::Builder::getPlannerSessionId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline void SlcAction::ConditionalManualAction::Builder::setPlannerSessionId( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder SlcAction::ConditionalManualAction::Builder::initPlannerSessionId(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), size);
}
inline void SlcAction::ConditionalManualAction::Builder::adoptPlannerSessionId(
    ::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> SlcAction::ConditionalManualAction::Builder::disownPlannerSessionId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}

inline  ::uint64_t SlcAction::ConditionalManualAction::Reader::getSourceCarStateMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcAction::ConditionalManualAction::Builder::getSourceCarStateMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}
inline void SlcAction::ConditionalManualAction::Builder::setSourceCarStateMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t SlcAction::ConditionalManualAction::Reader::getSourceSelfdriveStateMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcAction::ConditionalManualAction::Builder::getSourceSelfdriveStateMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS);
}
inline void SlcAction::ConditionalManualAction::Builder::setSourceSelfdriveStateMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS, value);
}

inline  ::uint8_t SlcAction::ConditionalManualAction::Reader::getExpectedManualCode() const {
  return _reader.getDataField< ::uint8_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}

inline  ::uint8_t SlcAction::ConditionalManualAction::Builder::getExpectedManualCode() {
  return _builder.getDataField< ::uint8_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}
inline void SlcAction::ConditionalManualAction::Builder::setExpectedManualCode( ::uint8_t value) {
  _builder.setDataField< ::uint8_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS, value);
}

inline bool SlcAction::ConditionalManualAction::Reader::getExpectedExperimental() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<40>() * ::capnp::ELEMENTS);
}

inline bool SlcAction::ConditionalManualAction::Builder::getExpectedExperimental() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<40>() * ::capnp::ELEMENTS);
}
inline void SlcAction::ConditionalManualAction::Builder::setExpectedExperimental(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<40>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t SlcCruiseEvent::Reader::getEventId() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcCruiseEvent::Builder::getEventId() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void SlcCruiseEvent::Builder::setEventId( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t SlcCruiseEvent::Reader::getObservedMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcCruiseEvent::Builder::getObservedMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void SlcCruiseEvent::Builder::setObservedMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

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

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

inline float SlcCruiseEvent::Reader::getSelectedMps() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}

inline float SlcCruiseEvent::Builder::getSelectedMps() {
  return _builder.getDataField<float>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}
inline void SlcCruiseEvent::Builder::setSelectedMps(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS, value);
}

inline  ::cereal::SlcCruiseEvent::Button SlcCruiseEvent::Reader::getButton() const {
  return _reader.getDataField< ::cereal::SlcCruiseEvent::Button>(
      ::capnp::bounded<12>() * ::capnp::ELEMENTS);
}

inline  ::cereal::SlcCruiseEvent::Button SlcCruiseEvent::Builder::getButton() {
  return _builder.getDataField< ::cereal::SlcCruiseEvent::Button>(
      ::capnp::bounded<12>() * ::capnp::ELEMENTS);
}
inline void SlcCruiseEvent::Builder::setButton( ::cereal::SlcCruiseEvent::Button value) {
  _builder.setDataField< ::cereal::SlcCruiseEvent::Button>(
      ::capnp::bounded<12>() * ::capnp::ELEMENTS, value);
}

inline bool SlcCruiseEvent::Reader::getLongPress() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<208>() * ::capnp::ELEMENTS);
}

inline bool SlcCruiseEvent::Builder::getLongPress() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<208>() * ::capnp::ELEMENTS);
}
inline void SlcCruiseEvent::Builder::setLongPress(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<208>() * ::capnp::ELEMENTS, value);
}

inline bool SlcCruiseEvent::Reader::hasProducerSessionId() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool SlcCruiseEvent::Builder::hasProducerSessionId() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader SlcCruiseEvent::Reader::getProducerSessionId() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder SlcCruiseEvent::Builder::getProducerSessionId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void SlcCruiseEvent::Builder::setProducerSessionId( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder SlcCruiseEvent::Builder::initProducerSessionId(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void SlcCruiseEvent::Builder::adoptProducerSessionId(
    ::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> SlcCruiseEvent::Builder::disownProducerSessionId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline  ::cereal::SlcCruiseEvent::Kind SlcCruiseEvent::Reader::getKind() const {
  return _reader.getDataField< ::cereal::SlcCruiseEvent::Kind>(
      ::capnp::bounded<14>() * ::capnp::ELEMENTS);
}

inline  ::cereal::SlcCruiseEvent::Kind SlcCruiseEvent::Builder::getKind() {
  return _builder.getDataField< ::cereal::SlcCruiseEvent::Kind>(
      ::capnp::bounded<14>() * ::capnp::ELEMENTS);
}
inline void SlcCruiseEvent::Builder::setKind( ::cereal::SlcCruiseEvent::Kind value) {
  _builder.setDataField< ::cereal::SlcCruiseEvent::Kind>(
      ::capnp::bounded<14>() * ::capnp::ELEMENTS, value);
}

inline bool SlcCruiseEvent::Reader::hasSessionId() const {
  return !_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline bool SlcCruiseEvent::Builder::hasSessionId() {
  return !_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader SlcCruiseEvent::Reader::getSessionId() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder SlcCruiseEvent::Builder::getSessionId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline void SlcCruiseEvent::Builder::setSessionId( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder SlcCruiseEvent::Builder::initSessionId(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), size);
}
inline void SlcCruiseEvent::Builder::adoptSessionId(
    ::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> SlcCruiseEvent::Builder::disownSessionId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}

inline  ::uint64_t SlcCruiseEvent::Reader::getDecisionId() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcCruiseEvent::Builder::getDecisionId() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}
inline void SlcCruiseEvent::Builder::setDecisionId( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t SlcCruiseEvent::Reader::getPresentationId() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcCruiseEvent::Builder::getPresentationId() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}
inline void SlcCruiseEvent::Builder::setPresentationId( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t SlcCruiseEvent::Reader::getCommandId() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcCruiseEvent::Builder::getCommandId() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS);
}
inline void SlcCruiseEvent::Builder::setCommandId( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS, value);
}

inline bool SlcCruiseEvent::Reader::hasManualMode() const {
  return !_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline bool SlcCruiseEvent::Builder::hasManualMode() {
  return !_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline  ::cereal::SlcCruiseEvent::ManualModeGesture::Reader SlcCruiseEvent::Reader::getManualMode() const {
  return ::capnp::_::PointerHelpers< ::cereal::SlcCruiseEvent::ManualModeGesture>::get(_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline  ::cereal::SlcCruiseEvent::ManualModeGesture::Builder SlcCruiseEvent::Builder::getManualMode() {
  return ::capnp::_::PointerHelpers< ::cereal::SlcCruiseEvent::ManualModeGesture>::get(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
#if !CAPNP_LITE
inline  ::cereal::SlcCruiseEvent::ManualModeGesture::Pipeline SlcCruiseEvent::Pipeline::getManualMode() {
  return  ::cereal::SlcCruiseEvent::ManualModeGesture::Pipeline(_typeless.getPointerField(2));
}
#endif  // !CAPNP_LITE
inline void SlcCruiseEvent::Builder::setManualMode( ::cereal::SlcCruiseEvent::ManualModeGesture::Reader value) {
  ::capnp::_::PointerHelpers< ::cereal::SlcCruiseEvent::ManualModeGesture>::set(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), value);
}
inline  ::cereal::SlcCruiseEvent::ManualModeGesture::Builder SlcCruiseEvent::Builder::initManualMode() {
  return ::capnp::_::PointerHelpers< ::cereal::SlcCruiseEvent::ManualModeGesture>::init(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline void SlcCruiseEvent::Builder::adoptManualMode(
    ::capnp::Orphan< ::cereal::SlcCruiseEvent::ManualModeGesture>&& value) {
  ::capnp::_::PointerHelpers< ::cereal::SlcCruiseEvent::ManualModeGesture>::adopt(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::cereal::SlcCruiseEvent::ManualModeGesture> SlcCruiseEvent::Builder::disownManualMode() {
  return ::capnp::_::PointerHelpers< ::cereal::SlcCruiseEvent::ManualModeGesture>::disown(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}

inline bool SlcCruiseEvent::Reader::hasTrafficMode() const {
  return !_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline bool SlcCruiseEvent::Builder::hasTrafficMode() {
  return !_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline  ::cereal::SlcCruiseEvent::TrafficModeGesture::Reader SlcCruiseEvent::Reader::getTrafficMode() const {
  return ::capnp::_::PointerHelpers< ::cereal::SlcCruiseEvent::TrafficModeGesture>::get(_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline  ::cereal::SlcCruiseEvent::TrafficModeGesture::Builder SlcCruiseEvent::Builder::getTrafficMode() {
  return ::capnp::_::PointerHelpers< ::cereal::SlcCruiseEvent::TrafficModeGesture>::get(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
#if !CAPNP_LITE
inline  ::cereal::SlcCruiseEvent::TrafficModeGesture::Pipeline SlcCruiseEvent::Pipeline::getTrafficMode() {
  return  ::cereal::SlcCruiseEvent::TrafficModeGesture::Pipeline(_typeless.getPointerField(3));
}
#endif  // !CAPNP_LITE
inline void SlcCruiseEvent::Builder::setTrafficMode( ::cereal::SlcCruiseEvent::TrafficModeGesture::Reader value) {
  ::capnp::_::PointerHelpers< ::cereal::SlcCruiseEvent::TrafficModeGesture>::set(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), value);
}
inline  ::cereal::SlcCruiseEvent::TrafficModeGesture::Builder SlcCruiseEvent::Builder::initTrafficMode() {
  return ::capnp::_::PointerHelpers< ::cereal::SlcCruiseEvent::TrafficModeGesture>::init(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline void SlcCruiseEvent::Builder::adoptTrafficMode(
    ::capnp::Orphan< ::cereal::SlcCruiseEvent::TrafficModeGesture>&& value) {
  ::capnp::_::PointerHelpers< ::cereal::SlcCruiseEvent::TrafficModeGesture>::adopt(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::cereal::SlcCruiseEvent::TrafficModeGesture> SlcCruiseEvent::Builder::disownTrafficMode() {
  return ::capnp::_::PointerHelpers< ::cereal::SlcCruiseEvent::TrafficModeGesture>::disown(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}

inline bool SlcCruiseEvent::Reader::hasWheelAction() const {
  return !_reader.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS).isNull();
}
inline bool SlcCruiseEvent::Builder::hasWheelAction() {
  return !_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS).isNull();
}
inline  ::cereal::SlcAction::ControllerCruiseAction::Reader SlcCruiseEvent::Reader::getWheelAction() const {
  return ::capnp::_::PointerHelpers< ::cereal::SlcAction::ControllerCruiseAction>::get(_reader.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}
inline  ::cereal::SlcAction::ControllerCruiseAction::Builder SlcCruiseEvent::Builder::getWheelAction() {
  return ::capnp::_::PointerHelpers< ::cereal::SlcAction::ControllerCruiseAction>::get(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}
#if !CAPNP_LITE
inline  ::cereal::SlcAction::ControllerCruiseAction::Pipeline SlcCruiseEvent::Pipeline::getWheelAction() {
  return  ::cereal::SlcAction::ControllerCruiseAction::Pipeline(_typeless.getPointerField(4));
}
#endif  // !CAPNP_LITE
inline void SlcCruiseEvent::Builder::setWheelAction( ::cereal::SlcAction::ControllerCruiseAction::Reader value) {
  ::capnp::_::PointerHelpers< ::cereal::SlcAction::ControllerCruiseAction>::set(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), value);
}
inline  ::cereal::SlcAction::ControllerCruiseAction::Builder SlcCruiseEvent::Builder::initWheelAction() {
  return ::capnp::_::PointerHelpers< ::cereal::SlcAction::ControllerCruiseAction>::init(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}
inline void SlcCruiseEvent::Builder::adoptWheelAction(
    ::capnp::Orphan< ::cereal::SlcAction::ControllerCruiseAction>&& value) {
  ::capnp::_::PointerHelpers< ::cereal::SlcAction::ControllerCruiseAction>::adopt(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::cereal::SlcAction::ControllerCruiseAction> SlcCruiseEvent::Builder::disownWheelAction() {
  return ::capnp::_::PointerHelpers< ::cereal::SlcAction::ControllerCruiseAction>::disown(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}

inline bool SlcCruiseEvent::Reader::hasTeslaStockCruise() const {
  return !_reader.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS).isNull();
}
inline bool SlcCruiseEvent::Builder::hasTeslaStockCruise() {
  return !_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS).isNull();
}
inline  ::cereal::SlcCruiseEvent::TeslaStockCruise::Reader SlcCruiseEvent::Reader::getTeslaStockCruise() const {
  return ::capnp::_::PointerHelpers< ::cereal::SlcCruiseEvent::TeslaStockCruise>::get(_reader.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS));
}
inline  ::cereal::SlcCruiseEvent::TeslaStockCruise::Builder SlcCruiseEvent::Builder::getTeslaStockCruise() {
  return ::capnp::_::PointerHelpers< ::cereal::SlcCruiseEvent::TeslaStockCruise>::get(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS));
}
#if !CAPNP_LITE
inline  ::cereal::SlcCruiseEvent::TeslaStockCruise::Pipeline SlcCruiseEvent::Pipeline::getTeslaStockCruise() {
  return  ::cereal::SlcCruiseEvent::TeslaStockCruise::Pipeline(_typeless.getPointerField(5));
}
#endif  // !CAPNP_LITE
inline void SlcCruiseEvent::Builder::setTeslaStockCruise( ::cereal::SlcCruiseEvent::TeslaStockCruise::Reader value) {
  ::capnp::_::PointerHelpers< ::cereal::SlcCruiseEvent::TeslaStockCruise>::set(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS), value);
}
inline  ::cereal::SlcCruiseEvent::TeslaStockCruise::Builder SlcCruiseEvent::Builder::initTeslaStockCruise() {
  return ::capnp::_::PointerHelpers< ::cereal::SlcCruiseEvent::TeslaStockCruise>::init(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS));
}
inline void SlcCruiseEvent::Builder::adoptTeslaStockCruise(
    ::capnp::Orphan< ::cereal::SlcCruiseEvent::TeslaStockCruise>&& value) {
  ::capnp::_::PointerHelpers< ::cereal::SlcCruiseEvent::TeslaStockCruise>::adopt(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::cereal::SlcCruiseEvent::TeslaStockCruise> SlcCruiseEvent::Builder::disownTeslaStockCruise() {
  return ::capnp::_::PointerHelpers< ::cereal::SlcCruiseEvent::TeslaStockCruise>::disown(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS));
}

inline  ::uint16_t SlcCruiseEvent::TeslaStockCruise::Reader::getVersion() const {
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline  ::uint16_t SlcCruiseEvent::TeslaStockCruise::Builder::getVersion() {
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void SlcCruiseEvent::TeslaStockCruise::Builder::setVersion( ::uint16_t value) {
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t SlcCruiseEvent::TeslaStockCruise::Reader::getCarStateMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcCruiseEvent::TeslaStockCruise::Builder::getCarStateMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void SlcCruiseEvent::TeslaStockCruise::Builder::setCarStateMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline bool SlcCruiseEvent::TeslaStockCruise::Reader::hasCpFingerprint() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool SlcCruiseEvent::TeslaStockCruise::Builder::hasCpFingerprint() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader SlcCruiseEvent::TeslaStockCruise::Reader::getCpFingerprint() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder SlcCruiseEvent::TeslaStockCruise::Builder::getCpFingerprint() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void SlcCruiseEvent::TeslaStockCruise::Builder::setCpFingerprint( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder SlcCruiseEvent::TeslaStockCruise::Builder::initCpFingerprint(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void SlcCruiseEvent::TeslaStockCruise::Builder::adoptCpFingerprint(
    ::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> SlcCruiseEvent::TeslaStockCruise::Builder::disownCpFingerprint() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline bool SlcCruiseEvent::TeslaStockCruise::Reader::getEngaged() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS);
}

inline bool SlcCruiseEvent::TeslaStockCruise::Builder::getEngaged() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS);
}
inline void SlcCruiseEvent::TeslaStockCruise::Builder::setEngaged(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS, value);
}

inline bool SlcCruiseEvent::TeslaStockCruise::Reader::getNotArmed() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<17>() * ::capnp::ELEMENTS);
}

inline bool SlcCruiseEvent::TeslaStockCruise::Builder::getNotArmed() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<17>() * ::capnp::ELEMENTS);
}
inline void SlcCruiseEvent::TeslaStockCruise::Builder::setNotArmed(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<17>() * ::capnp::ELEMENTS, value);
}

inline  ::uint16_t SlcCruiseEvent::TrafficModeGesture::Reader::getVersion() const {
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline  ::uint16_t SlcCruiseEvent::TrafficModeGesture::Builder::getVersion() {
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void SlcCruiseEvent::TrafficModeGesture::Builder::setVersion( ::uint16_t value) {
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool SlcCruiseEvent::TrafficModeGesture::Reader::hasSessionId() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool SlcCruiseEvent::TrafficModeGesture::Builder::hasSessionId() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader SlcCruiseEvent::TrafficModeGesture::Reader::getSessionId() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder SlcCruiseEvent::TrafficModeGesture::Builder::getSessionId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void SlcCruiseEvent::TrafficModeGesture::Builder::setSessionId( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder SlcCruiseEvent::TrafficModeGesture::Builder::initSessionId(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void SlcCruiseEvent::TrafficModeGesture::Builder::adoptSessionId(
    ::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> SlcCruiseEvent::TrafficModeGesture::Builder::disownSessionId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline  ::uint64_t SlcCruiseEvent::TrafficModeGesture::Reader::getSequence() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcCruiseEvent::TrafficModeGesture::Builder::getSequence() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void SlcCruiseEvent::TrafficModeGesture::Builder::setSequence( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t SlcCruiseEvent::TrafficModeGesture::Reader::getObservedMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcCruiseEvent::TrafficModeGesture::Builder::getObservedMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void SlcCruiseEvent::TrafficModeGesture::Builder::setObservedMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t SlcCruiseEvent::TrafficModeGesture::Reader::getDriveStartMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcCruiseEvent::TrafficModeGesture::Builder::getDriveStartMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}
inline void SlcCruiseEvent::TrafficModeGesture::Builder::setDriveStartMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS, value);
}

inline bool SlcCruiseEvent::TrafficModeGesture::Reader::hasSettingsFingerprint() const {
  return !_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline bool SlcCruiseEvent::TrafficModeGesture::Builder::hasSettingsFingerprint() {
  return !_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader SlcCruiseEvent::TrafficModeGesture::Reader::getSettingsFingerprint() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder SlcCruiseEvent::TrafficModeGesture::Builder::getSettingsFingerprint() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline void SlcCruiseEvent::TrafficModeGesture::Builder::setSettingsFingerprint( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder SlcCruiseEvent::TrafficModeGesture::Builder::initSettingsFingerprint(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), size);
}
inline void SlcCruiseEvent::TrafficModeGesture::Builder::adoptSettingsFingerprint(
    ::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> SlcCruiseEvent::TrafficModeGesture::Builder::disownSettingsFingerprint() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}

inline bool SlcCruiseEvent::TrafficModeGesture::Reader::hasButtonMapFingerprint() const {
  return !_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline bool SlcCruiseEvent::TrafficModeGesture::Builder::hasButtonMapFingerprint() {
  return !_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader SlcCruiseEvent::TrafficModeGesture::Reader::getButtonMapFingerprint() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder SlcCruiseEvent::TrafficModeGesture::Builder::getButtonMapFingerprint() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline void SlcCruiseEvent::TrafficModeGesture::Builder::setButtonMapFingerprint( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder SlcCruiseEvent::TrafficModeGesture::Builder::initButtonMapFingerprint(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), size);
}
inline void SlcCruiseEvent::TrafficModeGesture::Builder::adoptButtonMapFingerprint(
    ::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> SlcCruiseEvent::TrafficModeGesture::Builder::disownButtonMapFingerprint() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}

inline  ::uint64_t SlcCruiseEvent::TrafficModeGesture::Reader::getSourceEpoch() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcCruiseEvent::TrafficModeGesture::Builder::getSourceEpoch() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}
inline void SlcCruiseEvent::TrafficModeGesture::Builder::setSourceEpoch( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t SlcCruiseEvent::TrafficModeGesture::Reader::getSourceBootTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcCruiseEvent::TrafficModeGesture::Builder::getSourceBootTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}
inline void SlcCruiseEvent::TrafficModeGesture::Builder::setSourceBootTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t SlcCruiseEvent::TrafficModeGesture::Reader::getSourceCarStateMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcCruiseEvent::TrafficModeGesture::Builder::getSourceCarStateMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS);
}
inline void SlcCruiseEvent::TrafficModeGesture::Builder::setSourceCarStateMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t SlcCruiseEvent::TrafficModeGesture::Reader::getValidUntilMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<7>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcCruiseEvent::TrafficModeGesture::Builder::getValidUntilMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<7>() * ::capnp::ELEMENTS);
}
inline void SlcCruiseEvent::TrafficModeGesture::Builder::setValidUntilMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<7>() * ::capnp::ELEMENTS, value);
}

inline bool SlcCruiseEvent::TrafficModeGesture::Reader::getToggle() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS);
}

inline bool SlcCruiseEvent::TrafficModeGesture::Builder::getToggle() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS);
}
inline void SlcCruiseEvent::TrafficModeGesture::Builder::setToggle(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS, value);
}

inline  ::cereal::SlcCruiseEvent::TrafficModeGesture::Button SlcCruiseEvent::TrafficModeGesture::Reader::getButton() const {
  return _reader.getDataField< ::cereal::SlcCruiseEvent::TrafficModeGesture::Button>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline  ::cereal::SlcCruiseEvent::TrafficModeGesture::Button SlcCruiseEvent::TrafficModeGesture::Builder::getButton() {
  return _builder.getDataField< ::cereal::SlcCruiseEvent::TrafficModeGesture::Button>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void SlcCruiseEvent::TrafficModeGesture::Builder::setButton( ::cereal::SlcCruiseEvent::TrafficModeGesture::Button value) {
  _builder.setDataField< ::cereal::SlcCruiseEvent::TrafficModeGesture::Button>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline  ::cereal::SlcCruiseEvent::TrafficModeGesture::Press SlcCruiseEvent::TrafficModeGesture::Reader::getPress() const {
  return _reader.getDataField< ::cereal::SlcCruiseEvent::TrafficModeGesture::Press>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}

inline  ::cereal::SlcCruiseEvent::TrafficModeGesture::Press SlcCruiseEvent::TrafficModeGesture::Builder::getPress() {
  return _builder.getDataField< ::cereal::SlcCruiseEvent::TrafficModeGesture::Press>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}
inline void SlcCruiseEvent::TrafficModeGesture::Builder::setPress( ::cereal::SlcCruiseEvent::TrafficModeGesture::Press value) {
  _builder.setDataField< ::cereal::SlcCruiseEvent::TrafficModeGesture::Press>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS, value);
}

inline  ::uint16_t SlcCruiseEvent::ManualModeGesture::Reader::getVersion() const {
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline  ::uint16_t SlcCruiseEvent::ManualModeGesture::Builder::getVersion() {
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void SlcCruiseEvent::ManualModeGesture::Builder::setVersion( ::uint16_t value) {
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool SlcCruiseEvent::ManualModeGesture::Reader::hasSessionId() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool SlcCruiseEvent::ManualModeGesture::Builder::hasSessionId() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader SlcCruiseEvent::ManualModeGesture::Reader::getSessionId() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder SlcCruiseEvent::ManualModeGesture::Builder::getSessionId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void SlcCruiseEvent::ManualModeGesture::Builder::setSessionId( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder SlcCruiseEvent::ManualModeGesture::Builder::initSessionId(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void SlcCruiseEvent::ManualModeGesture::Builder::adoptSessionId(
    ::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> SlcCruiseEvent::ManualModeGesture::Builder::disownSessionId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline  ::uint64_t SlcCruiseEvent::ManualModeGesture::Reader::getSequence() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcCruiseEvent::ManualModeGesture::Builder::getSequence() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void SlcCruiseEvent::ManualModeGesture::Builder::setSequence( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t SlcCruiseEvent::ManualModeGesture::Reader::getObservedMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcCruiseEvent::ManualModeGesture::Builder::getObservedMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void SlcCruiseEvent::ManualModeGesture::Builder::setObservedMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t SlcCruiseEvent::ManualModeGesture::Reader::getDriveStartMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcCruiseEvent::ManualModeGesture::Builder::getDriveStartMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}
inline void SlcCruiseEvent::ManualModeGesture::Builder::setDriveStartMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS, value);
}

inline bool SlcCruiseEvent::ManualModeGesture::Reader::hasSettingsFingerprint() const {
  return !_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline bool SlcCruiseEvent::ManualModeGesture::Builder::hasSettingsFingerprint() {
  return !_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader SlcCruiseEvent::ManualModeGesture::Reader::getSettingsFingerprint() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder SlcCruiseEvent::ManualModeGesture::Builder::getSettingsFingerprint() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline void SlcCruiseEvent::ManualModeGesture::Builder::setSettingsFingerprint( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder SlcCruiseEvent::ManualModeGesture::Builder::initSettingsFingerprint(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), size);
}
inline void SlcCruiseEvent::ManualModeGesture::Builder::adoptSettingsFingerprint(
    ::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> SlcCruiseEvent::ManualModeGesture::Builder::disownSettingsFingerprint() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}

inline  ::cereal::SlcCruiseEvent::ManualModeGesture::Choice SlcCruiseEvent::ManualModeGesture::Reader::getChoice() const {
  return _reader.getDataField< ::cereal::SlcCruiseEvent::ManualModeGesture::Choice>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline  ::cereal::SlcCruiseEvent::ManualModeGesture::Choice SlcCruiseEvent::ManualModeGesture::Builder::getChoice() {
  return _builder.getDataField< ::cereal::SlcCruiseEvent::ManualModeGesture::Choice>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void SlcCruiseEvent::ManualModeGesture::Builder::setChoice( ::cereal::SlcCruiseEvent::ManualModeGesture::Choice value) {
  _builder.setDataField< ::cereal::SlcCruiseEvent::ManualModeGesture::Choice>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline  ::cereal::SlcCruiseEvent::ManualModeGesture::Button SlcCruiseEvent::ManualModeGesture::Reader::getButton() const {
  return _reader.getDataField< ::cereal::SlcCruiseEvent::ManualModeGesture::Button>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline  ::cereal::SlcCruiseEvent::ManualModeGesture::Button SlcCruiseEvent::ManualModeGesture::Builder::getButton() {
  return _builder.getDataField< ::cereal::SlcCruiseEvent::ManualModeGesture::Button>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void SlcCruiseEvent::ManualModeGesture::Builder::setButton( ::cereal::SlcCruiseEvent::ManualModeGesture::Button value) {
  _builder.setDataField< ::cereal::SlcCruiseEvent::ManualModeGesture::Button>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline  ::cereal::SlcCruiseEvent::ManualModeGesture::Press SlcCruiseEvent::ManualModeGesture::Reader::getPress() const {
  return _reader.getDataField< ::cereal::SlcCruiseEvent::ManualModeGesture::Press>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}

inline  ::cereal::SlcCruiseEvent::ManualModeGesture::Press SlcCruiseEvent::ManualModeGesture::Builder::getPress() {
  return _builder.getDataField< ::cereal::SlcCruiseEvent::ManualModeGesture::Press>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}
inline void SlcCruiseEvent::ManualModeGesture::Builder::setPress( ::cereal::SlcCruiseEvent::ManualModeGesture::Press value) {
  _builder.setDataField< ::cereal::SlcCruiseEvent::ManualModeGesture::Press>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t SlcCruiseEvent::ManualModeGesture::Reader::getSourceCarStateMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcCruiseEvent::ManualModeGesture::Builder::getSourceCarStateMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}
inline void SlcCruiseEvent::ManualModeGesture::Builder::setSourceCarStateMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t SlcCruiseEvent::ManualModeGesture::Reader::getValidUntilMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcCruiseEvent::ManualModeGesture::Builder::getValidUntilMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}
inline void SlcCruiseEvent::ManualModeGesture::Builder::setValidUntilMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS, value);
}

inline bool SlcDashboardObservation::Reader::hasProducerSessionId() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool SlcDashboardObservation::Builder::hasProducerSessionId() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader SlcDashboardObservation::Reader::getProducerSessionId() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder SlcDashboardObservation::Builder::getProducerSessionId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void SlcDashboardObservation::Builder::setProducerSessionId( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder SlcDashboardObservation::Builder::initProducerSessionId(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void SlcDashboardObservation::Builder::adoptProducerSessionId(
    ::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> SlcDashboardObservation::Builder::disownProducerSessionId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline  ::uint64_t SlcDashboardObservation::Reader::getCarStateLogMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcDashboardObservation::Builder::getCarStateLogMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void SlcDashboardObservation::Builder::setCarStateLogMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline  ::cereal::SlcDashboardObservation::Status SlcDashboardObservation::Reader::getStatus() const {
  return _reader.getDataField< ::cereal::SlcDashboardObservation::Status>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}

inline  ::cereal::SlcDashboardObservation::Status SlcDashboardObservation::Builder::getStatus() {
  return _builder.getDataField< ::cereal::SlcDashboardObservation::Status>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}
inline void SlcDashboardObservation::Builder::setStatus( ::cereal::SlcDashboardObservation::Status value) {
  _builder.setDataField< ::cereal::SlcDashboardObservation::Status>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS, value);
}

inline float SlcDashboardObservation::Reader::getSpeedMps() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}

inline float SlcDashboardObservation::Builder::getSpeedMps() {
  return _builder.getDataField<float>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}
inline void SlcDashboardObservation::Builder::setSpeedMps(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t SlcDashboardObservation::Reader::getObservedMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcDashboardObservation::Builder::getObservedMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void SlcDashboardObservation::Builder::setObservedMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t SlcDashboardObservation::Reader::getValidUntilMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcDashboardObservation::Builder::getValidUntilMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}
inline void SlcDashboardObservation::Builder::setValidUntilMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS, value);
}

inline  ::uint32_t SlcDashboardObservation::Reader::getEpisode() const {
  return _reader.getDataField< ::uint32_t>(
      ::capnp::bounded<8>() * ::capnp::ELEMENTS);
}

inline  ::uint32_t SlcDashboardObservation::Builder::getEpisode() {
  return _builder.getDataField< ::uint32_t>(
      ::capnp::bounded<8>() * ::capnp::ELEMENTS);
}
inline void SlcDashboardObservation::Builder::setEpisode( ::uint32_t value) {
  _builder.setDataField< ::uint32_t>(
      ::capnp::bounded<8>() * ::capnp::ELEMENTS, value);
}

inline  ::cereal::StarPilotModelDataV2::TurnDirection StarPilotModelDataV2::Reader::getTurnDirection() const {
  return _reader.getDataField< ::cereal::StarPilotModelDataV2::TurnDirection>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline  ::cereal::StarPilotModelDataV2::TurnDirection StarPilotModelDataV2::Builder::getTurnDirection() {
  return _builder.getDataField< ::cereal::StarPilotModelDataV2::TurnDirection>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void StarPilotModelDataV2::Builder::setTurnDirection( ::cereal::StarPilotModelDataV2::TurnDirection value) {
  _builder.setDataField< ::cereal::StarPilotModelDataV2::TurnDirection>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotModelDataV2::Reader::hasVision() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotModelDataV2::Builder::hasVision() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::cereal::StarPilotModelDataV2::VisionObservation::Reader StarPilotModelDataV2::Reader::getVision() const {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotModelDataV2::VisionObservation>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::cereal::StarPilotModelDataV2::VisionObservation::Builder StarPilotModelDataV2::Builder::getVision() {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotModelDataV2::VisionObservation>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
#if !CAPNP_LITE
inline  ::cereal::StarPilotModelDataV2::VisionObservation::Pipeline StarPilotModelDataV2::Pipeline::getVision() {
  return  ::cereal::StarPilotModelDataV2::VisionObservation::Pipeline(_typeless.getPointerField(0));
}
#endif  // !CAPNP_LITE
inline void StarPilotModelDataV2::Builder::setVision( ::cereal::StarPilotModelDataV2::VisionObservation::Reader value) {
  ::capnp::_::PointerHelpers< ::cereal::StarPilotModelDataV2::VisionObservation>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::cereal::StarPilotModelDataV2::VisionObservation::Builder StarPilotModelDataV2::Builder::initVision() {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotModelDataV2::VisionObservation>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void StarPilotModelDataV2::Builder::adoptVision(
    ::capnp::Orphan< ::cereal::StarPilotModelDataV2::VisionObservation>&& value) {
  ::capnp::_::PointerHelpers< ::cereal::StarPilotModelDataV2::VisionObservation>::adopt(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::cereal::StarPilotModelDataV2::VisionObservation> StarPilotModelDataV2::Builder::disownVision() {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotModelDataV2::VisionObservation>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline bool StarPilotModelDataV2::VisionObservation::Reader::hasProducerSessionId() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotModelDataV2::VisionObservation::Builder::hasProducerSessionId() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader StarPilotModelDataV2::VisionObservation::Reader::getProducerSessionId() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder StarPilotModelDataV2::VisionObservation::Builder::getProducerSessionId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void StarPilotModelDataV2::VisionObservation::Builder::setProducerSessionId( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder StarPilotModelDataV2::VisionObservation::Builder::initProducerSessionId(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void StarPilotModelDataV2::VisionObservation::Builder::adoptProducerSessionId(
    ::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> StarPilotModelDataV2::VisionObservation::Builder::disownProducerSessionId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline  ::cereal::StarPilotModelDataV2::VisionObservation::Status StarPilotModelDataV2::VisionObservation::Reader::getStatus() const {
  return _reader.getDataField< ::cereal::StarPilotModelDataV2::VisionObservation::Status>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline  ::cereal::StarPilotModelDataV2::VisionObservation::Status StarPilotModelDataV2::VisionObservation::Builder::getStatus() {
  return _builder.getDataField< ::cereal::StarPilotModelDataV2::VisionObservation::Status>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void StarPilotModelDataV2::VisionObservation::Builder::setStatus( ::cereal::StarPilotModelDataV2::VisionObservation::Status value) {
  _builder.setDataField< ::cereal::StarPilotModelDataV2::VisionObservation::Status>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline float StarPilotModelDataV2::VisionObservation::Reader::getSpeedMps() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline float StarPilotModelDataV2::VisionObservation::Builder::getSpeedMps() {
  return _builder.getDataField<float>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void StarPilotModelDataV2::VisionObservation::Builder::setSpeedMps(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline float StarPilotModelDataV2::VisionObservation::Reader::getConfidence() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline float StarPilotModelDataV2::VisionObservation::Builder::getConfidence() {
  return _builder.getDataField<float>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void StarPilotModelDataV2::VisionObservation::Builder::setConfidence(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline  ::uint16_t StarPilotModelDataV2::VisionObservation::Reader::getSupportCount() const {
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline  ::uint16_t StarPilotModelDataV2::VisionObservation::Builder::getSupportCount() {
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void StarPilotModelDataV2::VisionObservation::Builder::setSupportCount( ::uint16_t value) {
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t StarPilotModelDataV2::VisionObservation::Reader::getObservedMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t StarPilotModelDataV2::VisionObservation::Builder::getObservedMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void StarPilotModelDataV2::VisionObservation::Builder::setObservedMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t StarPilotModelDataV2::VisionObservation::Reader::getValidUntilMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t StarPilotModelDataV2::VisionObservation::Builder::getValidUntilMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}
inline void StarPilotModelDataV2::VisionObservation::Builder::setValidUntilMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t StarPilotModelDataV2::VisionObservation::Reader::getCameraFrameEofBootTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t StarPilotModelDataV2::VisionObservation::Builder::getCameraFrameEofBootTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}
inline void StarPilotModelDataV2::VisionObservation::Builder::setCameraFrameEofBootTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS, value);
}

inline  ::uint32_t StarPilotModelDataV2::VisionObservation::Reader::getEpisode() const {
  return _reader.getDataField< ::uint32_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}

inline  ::uint32_t StarPilotModelDataV2::VisionObservation::Builder::getEpisode() {
  return _builder.getDataField< ::uint32_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}
inline void StarPilotModelDataV2::VisionObservation::Builder::setEpisode( ::uint32_t value) {
  _builder.setDataField< ::uint32_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotModelDataV2::VisionObservation::Reader::hasModelId() const {
  return !_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotModelDataV2::VisionObservation::Builder::hasModelId() {
  return !_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader StarPilotModelDataV2::VisionObservation::Reader::getModelId() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder StarPilotModelDataV2::VisionObservation::Builder::getModelId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline void StarPilotModelDataV2::VisionObservation::Builder::setModelId( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder StarPilotModelDataV2::VisionObservation::Builder::initModelId(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), size);
}
inline void StarPilotModelDataV2::VisionObservation::Builder::adoptModelId(
    ::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> StarPilotModelDataV2::VisionObservation::Builder::disownModelId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}

inline  ::uint32_t StarPilotModelDataV2::VisionObservation::Reader::getFrameId() const {
  return _reader.getDataField< ::uint32_t>(
      ::capnp::bounded<10>() * ::capnp::ELEMENTS);
}

inline  ::uint32_t StarPilotModelDataV2::VisionObservation::Builder::getFrameId() {
  return _builder.getDataField< ::uint32_t>(
      ::capnp::bounded<10>() * ::capnp::ELEMENTS);
}
inline void StarPilotModelDataV2::VisionObservation::Builder::setFrameId( ::uint32_t value) {
  _builder.setDataField< ::uint32_t>(
      ::capnp::bounded<10>() * ::capnp::ELEMENTS, value);
}

inline  ::cereal::StarPilotModelDataV2::VisionObservation::Stream StarPilotModelDataV2::VisionObservation::Reader::getStream() const {
  return _reader.getDataField< ::cereal::StarPilotModelDataV2::VisionObservation::Stream>(
      ::capnp::bounded<22>() * ::capnp::ELEMENTS);
}

inline  ::cereal::StarPilotModelDataV2::VisionObservation::Stream StarPilotModelDataV2::VisionObservation::Builder::getStream() {
  return _builder.getDataField< ::cereal::StarPilotModelDataV2::VisionObservation::Stream>(
      ::capnp::bounded<22>() * ::capnp::ELEMENTS);
}
inline void StarPilotModelDataV2::VisionObservation::Builder::setStream( ::cereal::StarPilotModelDataV2::VisionObservation::Stream value) {
  _builder.setDataField< ::cereal::StarPilotModelDataV2::VisionObservation::Stream>(
      ::capnp::bounded<22>() * ::capnp::ELEMENTS, value);
}

inline  ::uint16_t StarPilotSteeringTracking::Reader::getVersion() const {
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline  ::uint16_t StarPilotSteeringTracking::Builder::getVersion() {
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void StarPilotSteeringTracking::Builder::setVersion( ::uint16_t value) {
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotSteeringTracking::Reader::hasSourceReceipt() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotSteeringTracking::Builder::hasSourceReceipt() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::cereal::AutomaticLearningSourceReceipt::Reader StarPilotSteeringTracking::Reader::getSourceReceipt() const {
  return ::capnp::_::PointerHelpers< ::cereal::AutomaticLearningSourceReceipt>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::cereal::AutomaticLearningSourceReceipt::Builder StarPilotSteeringTracking::Builder::getSourceReceipt() {
  return ::capnp::_::PointerHelpers< ::cereal::AutomaticLearningSourceReceipt>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
#if !CAPNP_LITE
inline  ::cereal::AutomaticLearningSourceReceipt::Pipeline StarPilotSteeringTracking::Pipeline::getSourceReceipt() {
  return  ::cereal::AutomaticLearningSourceReceipt::Pipeline(_typeless.getPointerField(0));
}
#endif  // !CAPNP_LITE
inline void StarPilotSteeringTracking::Builder::setSourceReceipt( ::cereal::AutomaticLearningSourceReceipt::Reader value) {
  ::capnp::_::PointerHelpers< ::cereal::AutomaticLearningSourceReceipt>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::cereal::AutomaticLearningSourceReceipt::Builder StarPilotSteeringTracking::Builder::initSourceReceipt() {
  return ::capnp::_::PointerHelpers< ::cereal::AutomaticLearningSourceReceipt>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void StarPilotSteeringTracking::Builder::adoptSourceReceipt(
    ::capnp::Orphan< ::cereal::AutomaticLearningSourceReceipt>&& value) {
  ::capnp::_::PointerHelpers< ::cereal::AutomaticLearningSourceReceipt>::adopt(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::cereal::AutomaticLearningSourceReceipt> StarPilotSteeringTracking::Builder::disownSourceReceipt() {
  return ::capnp::_::PointerHelpers< ::cereal::AutomaticLearningSourceReceipt>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline bool StarPilotSteeringTracking::Reader::hasTrial() const {
  return !_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotSteeringTracking::Builder::hasTrial() {
  return !_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline  ::cereal::LiveTrackingTrial::Reader StarPilotSteeringTracking::Reader::getTrial() const {
  return ::capnp::_::PointerHelpers< ::cereal::LiveTrackingTrial>::get(_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline  ::cereal::LiveTrackingTrial::Builder StarPilotSteeringTracking::Builder::getTrial() {
  return ::capnp::_::PointerHelpers< ::cereal::LiveTrackingTrial>::get(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
#if !CAPNP_LITE
inline  ::cereal::LiveTrackingTrial::Pipeline StarPilotSteeringTracking::Pipeline::getTrial() {
  return  ::cereal::LiveTrackingTrial::Pipeline(_typeless.getPointerField(1));
}
#endif  // !CAPNP_LITE
inline void StarPilotSteeringTracking::Builder::setTrial( ::cereal::LiveTrackingTrial::Reader value) {
  ::capnp::_::PointerHelpers< ::cereal::LiveTrackingTrial>::set(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), value);
}
inline  ::cereal::LiveTrackingTrial::Builder StarPilotSteeringTracking::Builder::initTrial() {
  return ::capnp::_::PointerHelpers< ::cereal::LiveTrackingTrial>::init(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline void StarPilotSteeringTracking::Builder::adoptTrial(
    ::capnp::Orphan< ::cereal::LiveTrackingTrial>&& value) {
  ::capnp::_::PointerHelpers< ::cereal::LiveTrackingTrial>::adopt(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::cereal::LiveTrackingTrial> StarPilotSteeringTracking::Builder::disownTrial() {
  return ::capnp::_::PointerHelpers< ::cereal::LiveTrackingTrial>::disown(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}

inline bool StarPilotSteeringTracking::Reader::hasRestore() const {
  return !_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotSteeringTracking::Builder::hasRestore() {
  return !_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline  ::cereal::LiveTrackingRestore::Reader StarPilotSteeringTracking::Reader::getRestore() const {
  return ::capnp::_::PointerHelpers< ::cereal::LiveTrackingRestore>::get(_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline  ::cereal::LiveTrackingRestore::Builder StarPilotSteeringTracking::Builder::getRestore() {
  return ::capnp::_::PointerHelpers< ::cereal::LiveTrackingRestore>::get(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
#if !CAPNP_LITE
inline  ::cereal::LiveTrackingRestore::Pipeline StarPilotSteeringTracking::Pipeline::getRestore() {
  return  ::cereal::LiveTrackingRestore::Pipeline(_typeless.getPointerField(2));
}
#endif  // !CAPNP_LITE
inline void StarPilotSteeringTracking::Builder::setRestore( ::cereal::LiveTrackingRestore::Reader value) {
  ::capnp::_::PointerHelpers< ::cereal::LiveTrackingRestore>::set(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), value);
}
inline  ::cereal::LiveTrackingRestore::Builder StarPilotSteeringTracking::Builder::initRestore() {
  return ::capnp::_::PointerHelpers< ::cereal::LiveTrackingRestore>::init(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline void StarPilotSteeringTracking::Builder::adoptRestore(
    ::capnp::Orphan< ::cereal::LiveTrackingRestore>&& value) {
  ::capnp::_::PointerHelpers< ::cereal::LiveTrackingRestore>::adopt(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::cereal::LiveTrackingRestore> StarPilotSteeringTracking::Builder::disownRestore() {
  return ::capnp::_::PointerHelpers< ::cereal::LiveTrackingRestore>::disown(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}

inline float CustomReserved6::Reader::getAccelerationJerk() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline float CustomReserved6::Builder::getAccelerationJerk() {
  return _builder.getDataField<float>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void CustomReserved6::Builder::setAccelerationJerk(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool CustomReserved6::Reader::getCscControllingSpeed() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<32>() * ::capnp::ELEMENTS);
}

inline bool CustomReserved6::Builder::getCscControllingSpeed() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<32>() * ::capnp::ELEMENTS);
}
inline void CustomReserved6::Builder::setCscControllingSpeed(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<32>() * ::capnp::ELEMENTS, value);
}

inline float CustomReserved6::Reader::getCscSpeed() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline float CustomReserved6::Builder::getCscSpeed() {
  return _builder.getDataField<float>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void CustomReserved6::Builder::setCscSpeed(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline bool CustomReserved6::Reader::getCscTraining() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<33>() * ::capnp::ELEMENTS);
}

inline bool CustomReserved6::Builder::getCscTraining() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<33>() * ::capnp::ELEMENTS);
}
inline void CustomReserved6::Builder::setCscTraining(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<33>() * ::capnp::ELEMENTS, value);
}

inline float CustomReserved6::Reader::getDangerFactor() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}

inline float CustomReserved6::Builder::getDangerFactor() {
  return _builder.getDataField<float>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}
inline void CustomReserved6::Builder::setDangerFactor(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS, value);
}

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

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

inline  ::int64_t CustomReserved6::Reader::getDesiredFollowDistance() const {
  return _reader.getDataField< ::int64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}

inline  ::int64_t CustomReserved6::Builder::getDesiredFollowDistance() {
  return _builder.getDataField< ::int64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}
inline void CustomReserved6::Builder::setDesiredFollowDistance( ::int64_t value) {
  _builder.setDataField< ::int64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS, value);
}

inline bool CustomReserved6::Reader::getExperimentalMode() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<34>() * ::capnp::ELEMENTS);
}

inline bool CustomReserved6::Builder::getExperimentalMode() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<34>() * ::capnp::ELEMENTS);
}
inline void CustomReserved6::Builder::setExperimentalMode(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<34>() * ::capnp::ELEMENTS, value);
}

inline bool CustomReserved6::Reader::getForcingStop() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<35>() * ::capnp::ELEMENTS);
}

inline bool CustomReserved6::Builder::getForcingStop() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<35>() * ::capnp::ELEMENTS);
}
inline void CustomReserved6::Builder::setForcingStop(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<35>() * ::capnp::ELEMENTS, value);
}

inline float CustomReserved6::Reader::getForcingStopLength() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}

inline float CustomReserved6::Builder::getForcingStopLength() {
  return _builder.getDataField<float>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}
inline void CustomReserved6::Builder::setForcingStopLength(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS, value);
}

inline bool CustomReserved6::Reader::hasStarpilotEvents() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool CustomReserved6::Builder::hasStarpilotEvents() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline ::capnp::AnyPointer::Reader CustomReserved6::Reader::getStarpilotEvents() const {
  return ::capnp::AnyPointer::Reader(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline ::capnp::AnyPointer::Builder CustomReserved6::Builder::getStarpilotEvents() {
  return ::capnp::AnyPointer::Builder(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline ::capnp::AnyPointer::Builder CustomReserved6::Builder::initStarpilotEvents() {
  auto result = ::capnp::AnyPointer::Builder(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
  result.clear();
  return result;
}

inline bool CustomReserved6::Reader::hasStarpilotToggles() const {
  return !_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline bool CustomReserved6::Builder::hasStarpilotToggles() {
  return !_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader CustomReserved6::Reader::getStarpilotToggles() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder CustomReserved6::Builder::getStarpilotToggles() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline void CustomReserved6::Builder::setStarpilotToggles( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder CustomReserved6::Builder::initStarpilotToggles(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), size);
}
inline void CustomReserved6::Builder::adoptStarpilotToggles(
    ::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> CustomReserved6::Builder::disownStarpilotToggles() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}

inline float CustomReserved6::Reader::getIncreasedStoppedDistance() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<8>() * ::capnp::ELEMENTS);
}

inline float CustomReserved6::Builder::getIncreasedStoppedDistance() {
  return _builder.getDataField<float>(
      ::capnp::bounded<8>() * ::capnp::ELEMENTS);
}
inline void CustomReserved6::Builder::setIncreasedStoppedDistance(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<8>() * ::capnp::ELEMENTS, value);
}

inline bool CustomReserved6::Reader::getLateralCheck() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<36>() * ::capnp::ELEMENTS);
}

inline bool CustomReserved6::Builder::getLateralCheck() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<36>() * ::capnp::ELEMENTS);
}
inline void CustomReserved6::Builder::setLateralCheck(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<36>() * ::capnp::ELEMENTS, value);
}

inline float CustomReserved6::Reader::getLaneWidthLeft() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<9>() * ::capnp::ELEMENTS);
}

inline float CustomReserved6::Builder::getLaneWidthLeft() {
  return _builder.getDataField<float>(
      ::capnp::bounded<9>() * ::capnp::ELEMENTS);
}
inline void CustomReserved6::Builder::setLaneWidthLeft(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<9>() * ::capnp::ELEMENTS, value);
}

inline float CustomReserved6::Reader::getLaneWidthRight() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<10>() * ::capnp::ELEMENTS);
}

inline float CustomReserved6::Builder::getLaneWidthRight() {
  return _builder.getDataField<float>(
      ::capnp::bounded<10>() * ::capnp::ELEMENTS);
}
inline void CustomReserved6::Builder::setLaneWidthRight(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<10>() * ::capnp::ELEMENTS, value);
}

inline float CustomReserved6::Reader::getMaxAcceleration() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<11>() * ::capnp::ELEMENTS);
}

inline float CustomReserved6::Builder::getMaxAcceleration() {
  return _builder.getDataField<float>(
      ::capnp::bounded<11>() * ::capnp::ELEMENTS);
}
inline void CustomReserved6::Builder::setMaxAcceleration(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<11>() * ::capnp::ELEMENTS, value);
}

inline float CustomReserved6::Reader::getMinAcceleration() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<12>() * ::capnp::ELEMENTS);
}

inline float CustomReserved6::Builder::getMinAcceleration() {
  return _builder.getDataField<float>(
      ::capnp::bounded<12>() * ::capnp::ELEMENTS);
}
inline void CustomReserved6::Builder::setMinAcceleration(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<12>() * ::capnp::ELEMENTS, value);
}

inline bool CustomReserved6::Reader::getRedLight() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<37>() * ::capnp::ELEMENTS);
}

inline bool CustomReserved6::Builder::getRedLight() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<37>() * ::capnp::ELEMENTS);
}
inline void CustomReserved6::Builder::setRedLight(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<37>() * ::capnp::ELEMENTS, value);
}

inline float CustomReserved6::Reader::getRoadCurvature() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<13>() * ::capnp::ELEMENTS);
}

inline float CustomReserved6::Builder::getRoadCurvature() {
  return _builder.getDataField<float>(
      ::capnp::bounded<13>() * ::capnp::ELEMENTS);
}
inline void CustomReserved6::Builder::setRoadCurvature(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<13>() * ::capnp::ELEMENTS, value);
}

inline float CustomReserved6::Reader::getSlcMapSpeedLimit() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<14>() * ::capnp::ELEMENTS);
}

inline float CustomReserved6::Builder::getSlcMapSpeedLimit() {
  return _builder.getDataField<float>(
      ::capnp::bounded<14>() * ::capnp::ELEMENTS);
}
inline void CustomReserved6::Builder::setSlcMapSpeedLimit(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<14>() * ::capnp::ELEMENTS, value);
}

inline float CustomReserved6::Reader::getSlcMapboxSpeedLimit() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<15>() * ::capnp::ELEMENTS);
}

inline float CustomReserved6::Builder::getSlcMapboxSpeedLimit() {
  return _builder.getDataField<float>(
      ::capnp::bounded<15>() * ::capnp::ELEMENTS);
}
inline void CustomReserved6::Builder::setSlcMapboxSpeedLimit(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<15>() * ::capnp::ELEMENTS, value);
}

inline float CustomReserved6::Reader::getSlcNextSpeedLimit() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS);
}

inline float CustomReserved6::Builder::getSlcNextSpeedLimit() {
  return _builder.getDataField<float>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS);
}
inline void CustomReserved6::Builder::setSlcNextSpeedLimit(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS, value);
}

inline float CustomReserved6::Reader::getSlcOverriddenSpeed() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<17>() * ::capnp::ELEMENTS);
}

inline float CustomReserved6::Builder::getSlcOverriddenSpeed() {
  return _builder.getDataField<float>(
      ::capnp::bounded<17>() * ::capnp::ELEMENTS);
}
inline void CustomReserved6::Builder::setSlcOverriddenSpeed(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<17>() * ::capnp::ELEMENTS, value);
}

inline float CustomReserved6::Reader::getSlcSpeedLimit() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<18>() * ::capnp::ELEMENTS);
}

inline float CustomReserved6::Builder::getSlcSpeedLimit() {
  return _builder.getDataField<float>(
      ::capnp::bounded<18>() * ::capnp::ELEMENTS);
}
inline void CustomReserved6::Builder::setSlcSpeedLimit(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<18>() * ::capnp::ELEMENTS, value);
}

inline float CustomReserved6::Reader::getSlcSpeedLimitOffset() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<19>() * ::capnp::ELEMENTS);
}

inline float CustomReserved6::Builder::getSlcSpeedLimitOffset() {
  return _builder.getDataField<float>(
      ::capnp::bounded<19>() * ::capnp::ELEMENTS);
}
inline void CustomReserved6::Builder::setSlcSpeedLimitOffset(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<19>() * ::capnp::ELEMENTS, value);
}

inline bool CustomReserved6::Reader::hasSlcSpeedLimitSource() const {
  return !_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline bool CustomReserved6::Builder::hasSlcSpeedLimitSource() {
  return !_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader CustomReserved6::Reader::getSlcSpeedLimitSource() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder CustomReserved6::Builder::getSlcSpeedLimitSource() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline void CustomReserved6::Builder::setSlcSpeedLimitSource( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder CustomReserved6::Builder::initSlcSpeedLimitSource(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), size);
}
inline void CustomReserved6::Builder::adoptSlcSpeedLimitSource(
    ::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> CustomReserved6::Builder::disownSlcSpeedLimitSource() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}

inline bool StarPilotRadarState::Reader::hasLeadLeft() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotRadarState::Builder::hasLeadLeft() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::cereal::StarPilotRadarState::LeadData::Reader StarPilotRadarState::Reader::getLeadLeft() const {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotRadarState::LeadData>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::cereal::StarPilotRadarState::LeadData::Builder StarPilotRadarState::Builder::getLeadLeft() {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotRadarState::LeadData>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
#if !CAPNP_LITE
inline  ::cereal::StarPilotRadarState::LeadData::Pipeline StarPilotRadarState::Pipeline::getLeadLeft() {
  return  ::cereal::StarPilotRadarState::LeadData::Pipeline(_typeless.getPointerField(0));
}
#endif  // !CAPNP_LITE
inline void StarPilotRadarState::Builder::setLeadLeft( ::cereal::StarPilotRadarState::LeadData::Reader value) {
  ::capnp::_::PointerHelpers< ::cereal::StarPilotRadarState::LeadData>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::cereal::StarPilotRadarState::LeadData::Builder StarPilotRadarState::Builder::initLeadLeft() {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotRadarState::LeadData>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void StarPilotRadarState::Builder::adoptLeadLeft(
    ::capnp::Orphan< ::cereal::StarPilotRadarState::LeadData>&& value) {
  ::capnp::_::PointerHelpers< ::cereal::StarPilotRadarState::LeadData>::adopt(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::cereal::StarPilotRadarState::LeadData> StarPilotRadarState::Builder::disownLeadLeft() {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotRadarState::LeadData>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline bool StarPilotRadarState::Reader::hasLeadRight() const {
  return !_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotRadarState::Builder::hasLeadRight() {
  return !_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline  ::cereal::StarPilotRadarState::LeadData::Reader StarPilotRadarState::Reader::getLeadRight() const {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotRadarState::LeadData>::get(_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline  ::cereal::StarPilotRadarState::LeadData::Builder StarPilotRadarState::Builder::getLeadRight() {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotRadarState::LeadData>::get(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
#if !CAPNP_LITE
inline  ::cereal::StarPilotRadarState::LeadData::Pipeline StarPilotRadarState::Pipeline::getLeadRight() {
  return  ::cereal::StarPilotRadarState::LeadData::Pipeline(_typeless.getPointerField(1));
}
#endif  // !CAPNP_LITE
inline void StarPilotRadarState::Builder::setLeadRight( ::cereal::StarPilotRadarState::LeadData::Reader value) {
  ::capnp::_::PointerHelpers< ::cereal::StarPilotRadarState::LeadData>::set(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), value);
}
inline  ::cereal::StarPilotRadarState::LeadData::Builder StarPilotRadarState::Builder::initLeadRight() {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotRadarState::LeadData>::init(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline void StarPilotRadarState::Builder::adoptLeadRight(
    ::capnp::Orphan< ::cereal::StarPilotRadarState::LeadData>&& value) {
  ::capnp::_::PointerHelpers< ::cereal::StarPilotRadarState::LeadData>::adopt(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::cereal::StarPilotRadarState::LeadData> StarPilotRadarState::Builder::disownLeadRight() {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotRadarState::LeadData>::disown(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}

inline bool StarPilotRadarState::Reader::hasAdjacentStopped() const {
  return !_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotRadarState::Builder::hasAdjacentStopped() {
  return !_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline  ::cereal::StarPilotRadarState::AdjacentStopped::Reader StarPilotRadarState::Reader::getAdjacentStopped() const {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotRadarState::AdjacentStopped>::get(_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline  ::cereal::StarPilotRadarState::AdjacentStopped::Builder StarPilotRadarState::Builder::getAdjacentStopped() {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotRadarState::AdjacentStopped>::get(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
#if !CAPNP_LITE
inline  ::cereal::StarPilotRadarState::AdjacentStopped::Pipeline StarPilotRadarState::Pipeline::getAdjacentStopped() {
  return  ::cereal::StarPilotRadarState::AdjacentStopped::Pipeline(_typeless.getPointerField(2));
}
#endif  // !CAPNP_LITE
inline void StarPilotRadarState::Builder::setAdjacentStopped( ::cereal::StarPilotRadarState::AdjacentStopped::Reader value) {
  ::capnp::_::PointerHelpers< ::cereal::StarPilotRadarState::AdjacentStopped>::set(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), value);
}
inline  ::cereal::StarPilotRadarState::AdjacentStopped::Builder StarPilotRadarState::Builder::initAdjacentStopped() {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotRadarState::AdjacentStopped>::init(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline void StarPilotRadarState::Builder::adoptAdjacentStopped(
    ::capnp::Orphan< ::cereal::StarPilotRadarState::AdjacentStopped>&& value) {
  ::capnp::_::PointerHelpers< ::cereal::StarPilotRadarState::AdjacentStopped>::adopt(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::cereal::StarPilotRadarState::AdjacentStopped> StarPilotRadarState::Builder::disownAdjacentStopped() {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotRadarState::AdjacentStopped>::disown(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}

inline bool StarPilotRadarState::Reader::hasQualifiedAdjacent() const {
  return !_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotRadarState::Builder::hasQualifiedAdjacent() {
  return !_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline  ::cereal::StarPilotRadarState::QualifiedAdjacent::Reader StarPilotRadarState::Reader::getQualifiedAdjacent() const {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotRadarState::QualifiedAdjacent>::get(_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline  ::cereal::StarPilotRadarState::QualifiedAdjacent::Builder StarPilotRadarState::Builder::getQualifiedAdjacent() {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotRadarState::QualifiedAdjacent>::get(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
#if !CAPNP_LITE
inline  ::cereal::StarPilotRadarState::QualifiedAdjacent::Pipeline StarPilotRadarState::Pipeline::getQualifiedAdjacent() {
  return  ::cereal::StarPilotRadarState::QualifiedAdjacent::Pipeline(_typeless.getPointerField(3));
}
#endif  // !CAPNP_LITE
inline void StarPilotRadarState::Builder::setQualifiedAdjacent( ::cereal::StarPilotRadarState::QualifiedAdjacent::Reader value) {
  ::capnp::_::PointerHelpers< ::cereal::StarPilotRadarState::QualifiedAdjacent>::set(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), value);
}
inline  ::cereal::StarPilotRadarState::QualifiedAdjacent::Builder StarPilotRadarState::Builder::initQualifiedAdjacent() {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotRadarState::QualifiedAdjacent>::init(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline void StarPilotRadarState::Builder::adoptQualifiedAdjacent(
    ::capnp::Orphan< ::cereal::StarPilotRadarState::QualifiedAdjacent>&& value) {
  ::capnp::_::PointerHelpers< ::cereal::StarPilotRadarState::QualifiedAdjacent>::adopt(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::cereal::StarPilotRadarState::QualifiedAdjacent> StarPilotRadarState::Builder::disownQualifiedAdjacent() {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotRadarState::QualifiedAdjacent>::disown(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}

inline bool StarPilotRadarState::AdjacentStopped::Reader::getStatus() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline bool StarPilotRadarState::AdjacentStopped::Builder::getStatus() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void StarPilotRadarState::AdjacentStopped::Builder::setStatus(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline float StarPilotRadarState::AdjacentStopped::Reader::getDRel() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline float StarPilotRadarState::AdjacentStopped::Builder::getDRel() {
  return _builder.getDataField<float>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void StarPilotRadarState::AdjacentStopped::Builder::setDRel(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline float StarPilotRadarState::AdjacentStopped::Reader::getYRel() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline float StarPilotRadarState::AdjacentStopped::Builder::getYRel() {
  return _builder.getDataField<float>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void StarPilotRadarState::AdjacentStopped::Builder::setYRel(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline  ::int32_t StarPilotRadarState::AdjacentStopped::Reader::getRadarTrackId() const {
  return _reader.getDataField< ::int32_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS, -1);
}

inline  ::int32_t StarPilotRadarState::AdjacentStopped::Builder::getRadarTrackId() {
  return _builder.getDataField< ::int32_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS, -1);
}
inline void StarPilotRadarState::AdjacentStopped::Builder::setRadarTrackId( ::int32_t value) {
  _builder.setDataField< ::int32_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS, value, -1);
}

inline float StarPilotRadarState::LeadData::Reader::getDRel() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline float StarPilotRadarState::LeadData::Builder::getDRel() {
  return _builder.getDataField<float>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void StarPilotRadarState::LeadData::Builder::setDRel(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline float StarPilotRadarState::LeadData::Reader::getYRel() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline float StarPilotRadarState::LeadData::Builder::getYRel() {
  return _builder.getDataField<float>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void StarPilotRadarState::LeadData::Builder::setYRel(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline float StarPilotRadarState::LeadData::Reader::getVRel() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline float StarPilotRadarState::LeadData::Builder::getVRel() {
  return _builder.getDataField<float>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void StarPilotRadarState::LeadData::Builder::setVRel(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline float StarPilotRadarState::LeadData::Reader::getARel() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}

inline float StarPilotRadarState::LeadData::Builder::getARel() {
  return _builder.getDataField<float>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}
inline void StarPilotRadarState::LeadData::Builder::setARel(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS, value);
}

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

inline float StarPilotRadarState::LeadData::Builder::getVLead() {
  return _builder.getDataField<float>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}
inline void StarPilotRadarState::LeadData::Builder::setVLead(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS, value);
}

inline float StarPilotRadarState::LeadData::Reader::getALeadDEPRECATED() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}

inline float StarPilotRadarState::LeadData::Builder::getALeadDEPRECATED() {
  return _builder.getDataField<float>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}
inline void StarPilotRadarState::LeadData::Builder::setALeadDEPRECATED(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS, value);
}

inline float StarPilotRadarState::LeadData::Reader::getDPath() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS);
}

inline float StarPilotRadarState::LeadData::Builder::getDPath() {
  return _builder.getDataField<float>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS);
}
inline void StarPilotRadarState::LeadData::Builder::setDPath(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS, value);
}

inline float StarPilotRadarState::LeadData::Reader::getVLat() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<7>() * ::capnp::ELEMENTS);
}

inline float StarPilotRadarState::LeadData::Builder::getVLat() {
  return _builder.getDataField<float>(
      ::capnp::bounded<7>() * ::capnp::ELEMENTS);
}
inline void StarPilotRadarState::LeadData::Builder::setVLat(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<7>() * ::capnp::ELEMENTS, value);
}

inline float StarPilotRadarState::LeadData::Reader::getVLeadK() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<8>() * ::capnp::ELEMENTS);
}

inline float StarPilotRadarState::LeadData::Builder::getVLeadK() {
  return _builder.getDataField<float>(
      ::capnp::bounded<8>() * ::capnp::ELEMENTS);
}
inline void StarPilotRadarState::LeadData::Builder::setVLeadK(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<8>() * ::capnp::ELEMENTS, value);
}

inline float StarPilotRadarState::LeadData::Reader::getALeadK() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<9>() * ::capnp::ELEMENTS);
}

inline float StarPilotRadarState::LeadData::Builder::getALeadK() {
  return _builder.getDataField<float>(
      ::capnp::bounded<9>() * ::capnp::ELEMENTS);
}
inline void StarPilotRadarState::LeadData::Builder::setALeadK(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<9>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotRadarState::LeadData::Reader::getFcw() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<320>() * ::capnp::ELEMENTS);
}

inline bool StarPilotRadarState::LeadData::Builder::getFcw() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<320>() * ::capnp::ELEMENTS);
}
inline void StarPilotRadarState::LeadData::Builder::setFcw(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<320>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotRadarState::LeadData::Reader::getStatus() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<321>() * ::capnp::ELEMENTS);
}

inline bool StarPilotRadarState::LeadData::Builder::getStatus() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<321>() * ::capnp::ELEMENTS);
}
inline void StarPilotRadarState::LeadData::Builder::setStatus(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<321>() * ::capnp::ELEMENTS, value);
}

inline float StarPilotRadarState::LeadData::Reader::getALeadTau() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<11>() * ::capnp::ELEMENTS);
}

inline float StarPilotRadarState::LeadData::Builder::getALeadTau() {
  return _builder.getDataField<float>(
      ::capnp::bounded<11>() * ::capnp::ELEMENTS);
}
inline void StarPilotRadarState::LeadData::Builder::setALeadTau(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<11>() * ::capnp::ELEMENTS, value);
}

inline float StarPilotRadarState::LeadData::Reader::getModelProb() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<12>() * ::capnp::ELEMENTS);
}

inline float StarPilotRadarState::LeadData::Builder::getModelProb() {
  return _builder.getDataField<float>(
      ::capnp::bounded<12>() * ::capnp::ELEMENTS);
}
inline void StarPilotRadarState::LeadData::Builder::setModelProb(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<12>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotRadarState::LeadData::Reader::getRadar() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<322>() * ::capnp::ELEMENTS);
}

inline bool StarPilotRadarState::LeadData::Builder::getRadar() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<322>() * ::capnp::ELEMENTS);
}
inline void StarPilotRadarState::LeadData::Builder::setRadar(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<322>() * ::capnp::ELEMENTS, value);
}

inline  ::int32_t StarPilotRadarState::LeadData::Reader::getRadarTrackId() const {
  return _reader.getDataField< ::int32_t>(
      ::capnp::bounded<13>() * ::capnp::ELEMENTS, -1);
}

inline  ::int32_t StarPilotRadarState::LeadData::Builder::getRadarTrackId() {
  return _builder.getDataField< ::int32_t>(
      ::capnp::bounded<13>() * ::capnp::ELEMENTS, -1);
}
inline void StarPilotRadarState::LeadData::Builder::setRadarTrackId( ::int32_t value) {
  _builder.setDataField< ::int32_t>(
      ::capnp::bounded<13>() * ::capnp::ELEMENTS, value, -1);
}

inline  ::uint16_t StarPilotRadarState::QualifiedAdjacent::Reader::getVersion() const {
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline  ::uint16_t StarPilotRadarState::QualifiedAdjacent::Builder::getVersion() {
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void StarPilotRadarState::QualifiedAdjacent::Builder::setVersion( ::uint16_t value) {
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline  ::cereal::StarPilotRadarState::QualifiedAdjacent::Status StarPilotRadarState::QualifiedAdjacent::Reader::getStatus() const {
  return _reader.getDataField< ::cereal::StarPilotRadarState::QualifiedAdjacent::Status>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline  ::cereal::StarPilotRadarState::QualifiedAdjacent::Status StarPilotRadarState::QualifiedAdjacent::Builder::getStatus() {
  return _builder.getDataField< ::cereal::StarPilotRadarState::QualifiedAdjacent::Status>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void StarPilotRadarState::QualifiedAdjacent::Builder::setStatus( ::cereal::StarPilotRadarState::QualifiedAdjacent::Status value) {
  _builder.setDataField< ::cereal::StarPilotRadarState::QualifiedAdjacent::Status>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotRadarState::QualifiedAdjacent::Reader::hasProducerSessionId() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotRadarState::QualifiedAdjacent::Builder::hasProducerSessionId() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader StarPilotRadarState::QualifiedAdjacent::Reader::getProducerSessionId() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder StarPilotRadarState::QualifiedAdjacent::Builder::getProducerSessionId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void StarPilotRadarState::QualifiedAdjacent::Builder::setProducerSessionId( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder StarPilotRadarState::QualifiedAdjacent::Builder::initProducerSessionId(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void StarPilotRadarState::QualifiedAdjacent::Builder::adoptProducerSessionId(
    ::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> StarPilotRadarState::QualifiedAdjacent::Builder::disownProducerSessionId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline  ::uint64_t StarPilotRadarState::QualifiedAdjacent::Reader::getSequence() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t StarPilotRadarState::QualifiedAdjacent::Builder::getSequence() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void StarPilotRadarState::QualifiedAdjacent::Builder::setSequence( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t StarPilotRadarState::QualifiedAdjacent::Reader::getRadarTracksMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t StarPilotRadarState::QualifiedAdjacent::Builder::getRadarTracksMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void StarPilotRadarState::QualifiedAdjacent::Builder::setRadarTracksMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t StarPilotRadarState::QualifiedAdjacent::Reader::getModelMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t StarPilotRadarState::QualifiedAdjacent::Builder::getModelMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}
inline void StarPilotRadarState::QualifiedAdjacent::Builder::setModelMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t StarPilotRadarState::QualifiedAdjacent::Reader::getCarStateMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t StarPilotRadarState::QualifiedAdjacent::Builder::getCarStateMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}
inline void StarPilotRadarState::QualifiedAdjacent::Builder::setCarStateMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t StarPilotRadarState::QualifiedAdjacent::Reader::getCameraEofBootTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t StarPilotRadarState::QualifiedAdjacent::Builder::getCameraEofBootTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}
inline void StarPilotRadarState::QualifiedAdjacent::Builder::setCameraEofBootTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t StarPilotRadarState::QualifiedAdjacent::Reader::getObservedMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t StarPilotRadarState::QualifiedAdjacent::Builder::getObservedMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS);
}
inline void StarPilotRadarState::QualifiedAdjacent::Builder::setObservedMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t StarPilotRadarState::QualifiedAdjacent::Reader::getValidUntilMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<7>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t StarPilotRadarState::QualifiedAdjacent::Builder::getValidUntilMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<7>() * ::capnp::ELEMENTS);
}
inline void StarPilotRadarState::QualifiedAdjacent::Builder::setValidUntilMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<7>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotRadarState::QualifiedAdjacent::Reader::hasLeft() const {
  return !_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotRadarState::QualifiedAdjacent::Builder::hasLeft() {
  return !_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline  ::cereal::StarPilotRadarState::QualifiedAdjacent::Candidate::Reader StarPilotRadarState::QualifiedAdjacent::Reader::getLeft() const {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotRadarState::QualifiedAdjacent::Candidate>::get(_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline  ::cereal::StarPilotRadarState::QualifiedAdjacent::Candidate::Builder StarPilotRadarState::QualifiedAdjacent::Builder::getLeft() {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotRadarState::QualifiedAdjacent::Candidate>::get(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
#if !CAPNP_LITE
inline  ::cereal::StarPilotRadarState::QualifiedAdjacent::Candidate::Pipeline StarPilotRadarState::QualifiedAdjacent::Pipeline::getLeft() {
  return  ::cereal::StarPilotRadarState::QualifiedAdjacent::Candidate::Pipeline(_typeless.getPointerField(1));
}
#endif  // !CAPNP_LITE
inline void StarPilotRadarState::QualifiedAdjacent::Builder::setLeft( ::cereal::StarPilotRadarState::QualifiedAdjacent::Candidate::Reader value) {
  ::capnp::_::PointerHelpers< ::cereal::StarPilotRadarState::QualifiedAdjacent::Candidate>::set(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), value);
}
inline  ::cereal::StarPilotRadarState::QualifiedAdjacent::Candidate::Builder StarPilotRadarState::QualifiedAdjacent::Builder::initLeft() {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotRadarState::QualifiedAdjacent::Candidate>::init(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline void StarPilotRadarState::QualifiedAdjacent::Builder::adoptLeft(
    ::capnp::Orphan< ::cereal::StarPilotRadarState::QualifiedAdjacent::Candidate>&& value) {
  ::capnp::_::PointerHelpers< ::cereal::StarPilotRadarState::QualifiedAdjacent::Candidate>::adopt(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::cereal::StarPilotRadarState::QualifiedAdjacent::Candidate> StarPilotRadarState::QualifiedAdjacent::Builder::disownLeft() {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotRadarState::QualifiedAdjacent::Candidate>::disown(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}

inline bool StarPilotRadarState::QualifiedAdjacent::Reader::hasRight() const {
  return !_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotRadarState::QualifiedAdjacent::Builder::hasRight() {
  return !_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline  ::cereal::StarPilotRadarState::QualifiedAdjacent::Candidate::Reader StarPilotRadarState::QualifiedAdjacent::Reader::getRight() const {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotRadarState::QualifiedAdjacent::Candidate>::get(_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline  ::cereal::StarPilotRadarState::QualifiedAdjacent::Candidate::Builder StarPilotRadarState::QualifiedAdjacent::Builder::getRight() {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotRadarState::QualifiedAdjacent::Candidate>::get(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
#if !CAPNP_LITE
inline  ::cereal::StarPilotRadarState::QualifiedAdjacent::Candidate::Pipeline StarPilotRadarState::QualifiedAdjacent::Pipeline::getRight() {
  return  ::cereal::StarPilotRadarState::QualifiedAdjacent::Candidate::Pipeline(_typeless.getPointerField(2));
}
#endif  // !CAPNP_LITE
inline void StarPilotRadarState::QualifiedAdjacent::Builder::setRight( ::cereal::StarPilotRadarState::QualifiedAdjacent::Candidate::Reader value) {
  ::capnp::_::PointerHelpers< ::cereal::StarPilotRadarState::QualifiedAdjacent::Candidate>::set(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), value);
}
inline  ::cereal::StarPilotRadarState::QualifiedAdjacent::Candidate::Builder StarPilotRadarState::QualifiedAdjacent::Builder::initRight() {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotRadarState::QualifiedAdjacent::Candidate>::init(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline void StarPilotRadarState::QualifiedAdjacent::Builder::adoptRight(
    ::capnp::Orphan< ::cereal::StarPilotRadarState::QualifiedAdjacent::Candidate>&& value) {
  ::capnp::_::PointerHelpers< ::cereal::StarPilotRadarState::QualifiedAdjacent::Candidate>::adopt(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::cereal::StarPilotRadarState::QualifiedAdjacent::Candidate> StarPilotRadarState::QualifiedAdjacent::Builder::disownRight() {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotRadarState::QualifiedAdjacent::Candidate>::disown(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}

inline bool StarPilotRadarState::QualifiedAdjacent::Candidate::Reader::getPresent() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline bool StarPilotRadarState::QualifiedAdjacent::Candidate::Builder::getPresent() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void StarPilotRadarState::QualifiedAdjacent::Candidate::Builder::setPresent(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline  ::uint32_t StarPilotRadarState::QualifiedAdjacent::Candidate::Reader::getTrackId() const {
  return _reader.getDataField< ::uint32_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline  ::uint32_t StarPilotRadarState::QualifiedAdjacent::Candidate::Builder::getTrackId() {
  return _builder.getDataField< ::uint32_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void StarPilotRadarState::QualifiedAdjacent::Candidate::Builder::setTrackId( ::uint32_t value) {
  _builder.setDataField< ::uint32_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline float StarPilotRadarState::QualifiedAdjacent::Candidate::Reader::getDistanceM() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline float StarPilotRadarState::QualifiedAdjacent::Candidate::Builder::getDistanceM() {
  return _builder.getDataField<float>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void StarPilotRadarState::QualifiedAdjacent::Candidate::Builder::setDistanceM(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline float StarPilotRadarState::QualifiedAdjacent::Candidate::Reader::getLateralM() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}

inline float StarPilotRadarState::QualifiedAdjacent::Candidate::Builder::getLateralM() {
  return _builder.getDataField<float>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}
inline void StarPilotRadarState::QualifiedAdjacent::Candidate::Builder::setLateralM(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS, value);
}

inline float StarPilotRadarState::QualifiedAdjacent::Candidate::Reader::getSpeedMps() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}

inline float StarPilotRadarState::QualifiedAdjacent::Candidate::Builder::getSpeedMps() {
  return _builder.getDataField<float>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}
inline void StarPilotRadarState::QualifiedAdjacent::Candidate::Builder::setSpeedMps(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotSelfdriveState::Reader::hasAlertText1() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotSelfdriveState::Builder::hasAlertText1() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader StarPilotSelfdriveState::Reader::getAlertText1() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder StarPilotSelfdriveState::Builder::getAlertText1() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void StarPilotSelfdriveState::Builder::setAlertText1( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder StarPilotSelfdriveState::Builder::initAlertText1(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void StarPilotSelfdriveState::Builder::adoptAlertText1(
    ::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> StarPilotSelfdriveState::Builder::disownAlertText1() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline bool StarPilotSelfdriveState::Reader::hasAlertText2() const {
  return !_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotSelfdriveState::Builder::hasAlertText2() {
  return !_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader StarPilotSelfdriveState::Reader::getAlertText2() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder StarPilotSelfdriveState::Builder::getAlertText2() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline void StarPilotSelfdriveState::Builder::setAlertText2( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder StarPilotSelfdriveState::Builder::initAlertText2(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), size);
}
inline void StarPilotSelfdriveState::Builder::adoptAlertText2(
    ::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> StarPilotSelfdriveState::Builder::disownAlertText2() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}

inline  ::cereal::StarPilotSelfdriveState::AlertStatus StarPilotSelfdriveState::Reader::getAlertStatus() const {
  return _reader.getDataField< ::cereal::StarPilotSelfdriveState::AlertStatus>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline  ::cereal::StarPilotSelfdriveState::AlertStatus StarPilotSelfdriveState::Builder::getAlertStatus() {
  return _builder.getDataField< ::cereal::StarPilotSelfdriveState::AlertStatus>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void StarPilotSelfdriveState::Builder::setAlertStatus( ::cereal::StarPilotSelfdriveState::AlertStatus value) {
  _builder.setDataField< ::cereal::StarPilotSelfdriveState::AlertStatus>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline  ::cereal::StarPilotSelfdriveState::AlertSize StarPilotSelfdriveState::Reader::getAlertSize() const {
  return _reader.getDataField< ::cereal::StarPilotSelfdriveState::AlertSize>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline  ::cereal::StarPilotSelfdriveState::AlertSize StarPilotSelfdriveState::Builder::getAlertSize() {
  return _builder.getDataField< ::cereal::StarPilotSelfdriveState::AlertSize>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void StarPilotSelfdriveState::Builder::setAlertSize( ::cereal::StarPilotSelfdriveState::AlertSize value) {
  _builder.setDataField< ::cereal::StarPilotSelfdriveState::AlertSize>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotSelfdriveState::Reader::hasAlertType() const {
  return !_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotSelfdriveState::Builder::hasAlertType() {
  return !_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader StarPilotSelfdriveState::Reader::getAlertType() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder StarPilotSelfdriveState::Builder::getAlertType() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline void StarPilotSelfdriveState::Builder::setAlertType( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder StarPilotSelfdriveState::Builder::initAlertType(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), size);
}
inline void StarPilotSelfdriveState::Builder::adoptAlertType(
    ::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> StarPilotSelfdriveState::Builder::disownAlertType() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}

inline  ::cereal::CarControl::HUDControl::AudibleAlert StarPilotSelfdriveState::Reader::getAlertSound() const {
  return _reader.getDataField< ::cereal::CarControl::HUDControl::AudibleAlert>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline  ::cereal::CarControl::HUDControl::AudibleAlert StarPilotSelfdriveState::Builder::getAlertSound() {
  return _builder.getDataField< ::cereal::CarControl::HUDControl::AudibleAlert>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void StarPilotSelfdriveState::Builder::setAlertSound( ::cereal::CarControl::HUDControl::AudibleAlert value) {
  _builder.setDataField< ::cereal::CarControl::HUDControl::AudibleAlert>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline float StarPilotSelfdriveState::Reader::getVEgo() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline float StarPilotSelfdriveState::Builder::getVEgo() {
  return _builder.getDataField<float>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void StarPilotSelfdriveState::Builder::setVEgo(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotSelfdriveState::Reader::hasConditionalModeAck() const {
  return !_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotSelfdriveState::Builder::hasConditionalModeAck() {
  return !_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline  ::cereal::StarPilotSelfdriveState::ConditionalModeAck::Reader StarPilotSelfdriveState::Reader::getConditionalModeAck() const {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotSelfdriveState::ConditionalModeAck>::get(_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline  ::cereal::StarPilotSelfdriveState::ConditionalModeAck::Builder StarPilotSelfdriveState::Builder::getConditionalModeAck() {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotSelfdriveState::ConditionalModeAck>::get(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
#if !CAPNP_LITE
inline  ::cereal::StarPilotSelfdriveState::ConditionalModeAck::Pipeline StarPilotSelfdriveState::Pipeline::getConditionalModeAck() {
  return  ::cereal::StarPilotSelfdriveState::ConditionalModeAck::Pipeline(_typeless.getPointerField(3));
}
#endif  // !CAPNP_LITE
inline void StarPilotSelfdriveState::Builder::setConditionalModeAck( ::cereal::StarPilotSelfdriveState::ConditionalModeAck::Reader value) {
  ::capnp::_::PointerHelpers< ::cereal::StarPilotSelfdriveState::ConditionalModeAck>::set(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), value);
}
inline  ::cereal::StarPilotSelfdriveState::ConditionalModeAck::Builder StarPilotSelfdriveState::Builder::initConditionalModeAck() {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotSelfdriveState::ConditionalModeAck>::init(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline void StarPilotSelfdriveState::Builder::adoptConditionalModeAck(
    ::capnp::Orphan< ::cereal::StarPilotSelfdriveState::ConditionalModeAck>&& value) {
  ::capnp::_::PointerHelpers< ::cereal::StarPilotSelfdriveState::ConditionalModeAck>::adopt(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::cereal::StarPilotSelfdriveState::ConditionalModeAck> StarPilotSelfdriveState::Builder::disownConditionalModeAck() {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotSelfdriveState::ConditionalModeAck>::disown(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}

inline  ::uint16_t StarPilotSelfdriveState::ConditionalModeAck::Reader::getVersion() const {
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline  ::uint16_t StarPilotSelfdriveState::ConditionalModeAck::Builder::getVersion() {
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void StarPilotSelfdriveState::ConditionalModeAck::Builder::setVersion( ::uint16_t value) {
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotSelfdriveState::ConditionalModeAck::Reader::hasSessionId() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotSelfdriveState::ConditionalModeAck::Builder::hasSessionId() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader StarPilotSelfdriveState::ConditionalModeAck::Reader::getSessionId() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder StarPilotSelfdriveState::ConditionalModeAck::Builder::getSessionId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void StarPilotSelfdriveState::ConditionalModeAck::Builder::setSessionId( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder StarPilotSelfdriveState::ConditionalModeAck::Builder::initSessionId(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void StarPilotSelfdriveState::ConditionalModeAck::Builder::adoptSessionId(
    ::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> StarPilotSelfdriveState::ConditionalModeAck::Builder::disownSessionId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline  ::uint64_t StarPilotSelfdriveState::ConditionalModeAck::Reader::getSequence() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t StarPilotSelfdriveState::ConditionalModeAck::Builder::getSequence() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void StarPilotSelfdriveState::ConditionalModeAck::Builder::setSequence( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t StarPilotSelfdriveState::ConditionalModeAck::Reader::getObservedMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t StarPilotSelfdriveState::ConditionalModeAck::Builder::getObservedMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void StarPilotSelfdriveState::ConditionalModeAck::Builder::setObservedMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t StarPilotSelfdriveState::ConditionalModeAck::Reader::getValidUntilMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t StarPilotSelfdriveState::ConditionalModeAck::Builder::getValidUntilMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}
inline void StarPilotSelfdriveState::ConditionalModeAck::Builder::setValidUntilMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t StarPilotSelfdriveState::ConditionalModeAck::Reader::getSourceSelfdriveStateMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t StarPilotSelfdriveState::ConditionalModeAck::Builder::getSourceSelfdriveStateMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}
inline void StarPilotSelfdriveState::ConditionalModeAck::Builder::setSourceSelfdriveStateMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t StarPilotSelfdriveState::ConditionalModeAck::Reader::getDriveStartMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t StarPilotSelfdriveState::ConditionalModeAck::Builder::getDriveStartMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}
inline void StarPilotSelfdriveState::ConditionalModeAck::Builder::setDriveStartMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS, value);
}

inline  ::cereal::SlcState::ConditionalModeState::Choice StarPilotSelfdriveState::ConditionalModeAck::Reader::getChoice() const {
  return _reader.getDataField< ::cereal::SlcState::ConditionalModeState::Choice>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline  ::cereal::SlcState::ConditionalModeState::Choice StarPilotSelfdriveState::ConditionalModeAck::Builder::getChoice() {
  return _builder.getDataField< ::cereal::SlcState::ConditionalModeState::Choice>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void StarPilotSelfdriveState::ConditionalModeAck::Builder::setChoice( ::cereal::SlcState::ConditionalModeState::Choice value) {
  _builder.setDataField< ::cereal::SlcState::ConditionalModeState::Choice>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotSelfdriveState::ConditionalModeAck::Reader::getAccepted() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<32>() * ::capnp::ELEMENTS);
}

inline bool StarPilotSelfdriveState::ConditionalModeAck::Builder::getAccepted() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<32>() * ::capnp::ELEMENTS);
}
inline void StarPilotSelfdriveState::ConditionalModeAck::Builder::setAccepted(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<32>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotSelfdriveState::ConditionalModeAck::Reader::getEffectiveExperimental() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<33>() * ::capnp::ELEMENTS);
}

inline bool StarPilotSelfdriveState::ConditionalModeAck::Builder::getEffectiveExperimental() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<33>() * ::capnp::ELEMENTS);
}
inline void StarPilotSelfdriveState::ConditionalModeAck::Builder::setEffectiveExperimental(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<33>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotSelfdriveState::ConditionalModeAck::Reader::hasPlannerSessionId() const {
  return !_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotSelfdriveState::ConditionalModeAck::Builder::hasPlannerSessionId() {
  return !_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader StarPilotSelfdriveState::ConditionalModeAck::Reader::getPlannerSessionId() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder StarPilotSelfdriveState::ConditionalModeAck::Builder::getPlannerSessionId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline void StarPilotSelfdriveState::ConditionalModeAck::Builder::setPlannerSessionId( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder StarPilotSelfdriveState::ConditionalModeAck::Builder::initPlannerSessionId(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), size);
}
inline void StarPilotSelfdriveState::ConditionalModeAck::Builder::adoptPlannerSessionId(
    ::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> StarPilotSelfdriveState::ConditionalModeAck::Builder::disownPlannerSessionId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}

inline  ::uint64_t StarPilotSelfdriveState::ConditionalModeAck::Reader::getPlannerSequence() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t StarPilotSelfdriveState::ConditionalModeAck::Builder::getPlannerSequence() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS);
}
inline void StarPilotSelfdriveState::ConditionalModeAck::Builder::setPlannerSequence( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotSelfdriveState::ConditionalModeAck::Reader::hasSettingsFingerprint() const {
  return !_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotSelfdriveState::ConditionalModeAck::Builder::hasSettingsFingerprint() {
  return !_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader StarPilotSelfdriveState::ConditionalModeAck::Reader::getSettingsFingerprint() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder StarPilotSelfdriveState::ConditionalModeAck::Builder::getSettingsFingerprint() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline void StarPilotSelfdriveState::ConditionalModeAck::Builder::setSettingsFingerprint( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder StarPilotSelfdriveState::ConditionalModeAck::Builder::initSettingsFingerprint(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), size);
}
inline void StarPilotSelfdriveState::ConditionalModeAck::Builder::adoptSettingsFingerprint(
    ::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> StarPilotSelfdriveState::ConditionalModeAck::Builder::disownSettingsFingerprint() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}

inline  ::uint64_t StarPilotSelfdriveState::ConditionalModeAck::Reader::getSettingsRevision() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<7>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t StarPilotSelfdriveState::ConditionalModeAck::Builder::getSettingsRevision() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<7>() * ::capnp::ELEMENTS);
}
inline void StarPilotSelfdriveState::ConditionalModeAck::Builder::setSettingsRevision( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<7>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t StarPilotSelfdriveState::ConditionalModeAck::Reader::getModelMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<8>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t StarPilotSelfdriveState::ConditionalModeAck::Builder::getModelMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<8>() * ::capnp::ELEMENTS);
}
inline void StarPilotSelfdriveState::ConditionalModeAck::Builder::setModelMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<8>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotSelfdriveState::ConditionalModeAck::Reader::hasReason() const {
  return !_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotSelfdriveState::ConditionalModeAck::Builder::hasReason() {
  return !_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader StarPilotSelfdriveState::ConditionalModeAck::Reader::getReason() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder StarPilotSelfdriveState::ConditionalModeAck::Builder::getReason() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline void StarPilotSelfdriveState::ConditionalModeAck::Builder::setReason( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder StarPilotSelfdriveState::ConditionalModeAck::Builder::initReason(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), size);
}
inline void StarPilotSelfdriveState::ConditionalModeAck::Builder::adoptReason(
    ::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> StarPilotSelfdriveState::ConditionalModeAck::Builder::disownReason() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}

inline  ::uint16_t StarPilotSelfdriveState::ConditionalModeAck::Reader::getStatusCode() const {
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}

inline  ::uint16_t StarPilotSelfdriveState::ConditionalModeAck::Builder::getStatusCode() {
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}
inline void StarPilotSelfdriveState::ConditionalModeAck::Builder::setStatusCode( ::uint16_t value) {
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS, value);
}

inline float SpotMonitorState::Reader::getDesiredCurvature() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline float SpotMonitorState::Builder::getDesiredCurvature() {
  return _builder.getDataField<float>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void SpotMonitorState::Builder::setDesiredCurvature(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool SpotMonitorState::Reader::hasObservation() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool SpotMonitorState::Builder::hasObservation() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::cereal::SpotMonitorState::Observation::Reader SpotMonitorState::Reader::getObservation() const {
  return ::capnp::_::PointerHelpers< ::cereal::SpotMonitorState::Observation>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::cereal::SpotMonitorState::Observation::Builder SpotMonitorState::Builder::getObservation() {
  return ::capnp::_::PointerHelpers< ::cereal::SpotMonitorState::Observation>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
#if !CAPNP_LITE
inline  ::cereal::SpotMonitorState::Observation::Pipeline SpotMonitorState::Pipeline::getObservation() {
  return  ::cereal::SpotMonitorState::Observation::Pipeline(_typeless.getPointerField(0));
}
#endif  // !CAPNP_LITE
inline void SpotMonitorState::Builder::setObservation( ::cereal::SpotMonitorState::Observation::Reader value) {
  ::capnp::_::PointerHelpers< ::cereal::SpotMonitorState::Observation>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::cereal::SpotMonitorState::Observation::Builder SpotMonitorState::Builder::initObservation() {
  return ::capnp::_::PointerHelpers< ::cereal::SpotMonitorState::Observation>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void SpotMonitorState::Builder::adoptObservation(
    ::capnp::Orphan< ::cereal::SpotMonitorState::Observation>&& value) {
  ::capnp::_::PointerHelpers< ::cereal::SpotMonitorState::Observation>::adopt(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::cereal::SpotMonitorState::Observation> SpotMonitorState::Builder::disownObservation() {
  return ::capnp::_::PointerHelpers< ::cereal::SpotMonitorState::Observation>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline  ::uint16_t SpotMonitorState::Observation::Reader::getVersion() const {
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline  ::uint16_t SpotMonitorState::Observation::Builder::getVersion() {
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void SpotMonitorState::Observation::Builder::setVersion( ::uint16_t value) {
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool SpotMonitorState::Observation::Reader::hasProducerSessionId() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool SpotMonitorState::Observation::Builder::hasProducerSessionId() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader SpotMonitorState::Observation::Reader::getProducerSessionId() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder SpotMonitorState::Observation::Builder::getProducerSessionId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void SpotMonitorState::Observation::Builder::setProducerSessionId( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder SpotMonitorState::Observation::Builder::initProducerSessionId(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void SpotMonitorState::Observation::Builder::adoptProducerSessionId(
    ::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> SpotMonitorState::Observation::Builder::disownProducerSessionId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline  ::uint64_t SpotMonitorState::Observation::Reader::getSequence() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SpotMonitorState::Observation::Builder::getSequence() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void SpotMonitorState::Observation::Builder::setSequence( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline bool SpotMonitorState::Observation::Reader::hasModelSha256() const {
  return !_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline bool SpotMonitorState::Observation::Builder::hasModelSha256() {
  return !_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader SpotMonitorState::Observation::Reader::getModelSha256() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder SpotMonitorState::Observation::Builder::getModelSha256() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline void SpotMonitorState::Observation::Builder::setModelSha256( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder SpotMonitorState::Observation::Builder::initModelSha256(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), size);
}
inline void SpotMonitorState::Observation::Builder::adoptModelSha256(
    ::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> SpotMonitorState::Observation::Builder::disownModelSha256() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}

inline bool SpotMonitorState::Observation::Reader::hasSettingsFingerprint() const {
  return !_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline bool SpotMonitorState::Observation::Builder::hasSettingsFingerprint() {
  return !_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader SpotMonitorState::Observation::Reader::getSettingsFingerprint() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder SpotMonitorState::Observation::Builder::getSettingsFingerprint() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline void SpotMonitorState::Observation::Builder::setSettingsFingerprint( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder SpotMonitorState::Observation::Builder::initSettingsFingerprint(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), size);
}
inline void SpotMonitorState::Observation::Builder::adoptSettingsFingerprint(
    ::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> SpotMonitorState::Observation::Builder::disownSettingsFingerprint() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}

inline  ::uint64_t SpotMonitorState::Observation::Reader::getObservedMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SpotMonitorState::Observation::Builder::getObservedMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void SpotMonitorState::Observation::Builder::setObservedMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t SpotMonitorState::Observation::Reader::getObservedBootTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SpotMonitorState::Observation::Builder::getObservedBootTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}
inline void SpotMonitorState::Observation::Builder::setObservedBootTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t SpotMonitorState::Observation::Reader::getSourceFrameId() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SpotMonitorState::Observation::Builder::getSourceFrameId() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}
inline void SpotMonitorState::Observation::Builder::setSourceFrameId( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t SpotMonitorState::Observation::Reader::getSourceFrameEofBootTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SpotMonitorState::Observation::Builder::getSourceFrameEofBootTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}
inline void SpotMonitorState::Observation::Builder::setSourceFrameEofBootTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t SpotMonitorState::Observation::Reader::getValidUntilBootTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SpotMonitorState::Observation::Builder::getValidUntilBootTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS);
}
inline void SpotMonitorState::Observation::Builder::setValidUntilBootTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS, value);
}

inline bool SpotMonitorState::Observation::Reader::hasLeft() const {
  return !_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline bool SpotMonitorState::Observation::Builder::hasLeft() {
  return !_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline  ::cereal::SpotMonitorState::Observation::Side::Reader SpotMonitorState::Observation::Reader::getLeft() const {
  return ::capnp::_::PointerHelpers< ::cereal::SpotMonitorState::Observation::Side>::get(_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline  ::cereal::SpotMonitorState::Observation::Side::Builder SpotMonitorState::Observation::Builder::getLeft() {
  return ::capnp::_::PointerHelpers< ::cereal::SpotMonitorState::Observation::Side>::get(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
#if !CAPNP_LITE
inline  ::cereal::SpotMonitorState::Observation::Side::Pipeline SpotMonitorState::Observation::Pipeline::getLeft() {
  return  ::cereal::SpotMonitorState::Observation::Side::Pipeline(_typeless.getPointerField(3));
}
#endif  // !CAPNP_LITE
inline void SpotMonitorState::Observation::Builder::setLeft( ::cereal::SpotMonitorState::Observation::Side::Reader value) {
  ::capnp::_::PointerHelpers< ::cereal::SpotMonitorState::Observation::Side>::set(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), value);
}
inline  ::cereal::SpotMonitorState::Observation::Side::Builder SpotMonitorState::Observation::Builder::initLeft() {
  return ::capnp::_::PointerHelpers< ::cereal::SpotMonitorState::Observation::Side>::init(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline void SpotMonitorState::Observation::Builder::adoptLeft(
    ::capnp::Orphan< ::cereal::SpotMonitorState::Observation::Side>&& value) {
  ::capnp::_::PointerHelpers< ::cereal::SpotMonitorState::Observation::Side>::adopt(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::cereal::SpotMonitorState::Observation::Side> SpotMonitorState::Observation::Builder::disownLeft() {
  return ::capnp::_::PointerHelpers< ::cereal::SpotMonitorState::Observation::Side>::disown(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}

inline bool SpotMonitorState::Observation::Reader::hasRight() const {
  return !_reader.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS).isNull();
}
inline bool SpotMonitorState::Observation::Builder::hasRight() {
  return !_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS).isNull();
}
inline  ::cereal::SpotMonitorState::Observation::Side::Reader SpotMonitorState::Observation::Reader::getRight() const {
  return ::capnp::_::PointerHelpers< ::cereal::SpotMonitorState::Observation::Side>::get(_reader.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}
inline  ::cereal::SpotMonitorState::Observation::Side::Builder SpotMonitorState::Observation::Builder::getRight() {
  return ::capnp::_::PointerHelpers< ::cereal::SpotMonitorState::Observation::Side>::get(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}
#if !CAPNP_LITE
inline  ::cereal::SpotMonitorState::Observation::Side::Pipeline SpotMonitorState::Observation::Pipeline::getRight() {
  return  ::cereal::SpotMonitorState::Observation::Side::Pipeline(_typeless.getPointerField(4));
}
#endif  // !CAPNP_LITE
inline void SpotMonitorState::Observation::Builder::setRight( ::cereal::SpotMonitorState::Observation::Side::Reader value) {
  ::capnp::_::PointerHelpers< ::cereal::SpotMonitorState::Observation::Side>::set(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), value);
}
inline  ::cereal::SpotMonitorState::Observation::Side::Builder SpotMonitorState::Observation::Builder::initRight() {
  return ::capnp::_::PointerHelpers< ::cereal::SpotMonitorState::Observation::Side>::init(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}
inline void SpotMonitorState::Observation::Builder::adoptRight(
    ::capnp::Orphan< ::cereal::SpotMonitorState::Observation::Side>&& value) {
  ::capnp::_::PointerHelpers< ::cereal::SpotMonitorState::Observation::Side>::adopt(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::cereal::SpotMonitorState::Observation::Side> SpotMonitorState::Observation::Builder::disownRight() {
  return ::capnp::_::PointerHelpers< ::cereal::SpotMonitorState::Observation::Side>::disown(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}

inline  ::cereal::SpotMonitorState::Observation::Side::Status SpotMonitorState::Observation::Side::Reader::getStatus() const {
  return _reader.getDataField< ::cereal::SpotMonitorState::Observation::Side::Status>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline  ::cereal::SpotMonitorState::Observation::Side::Status SpotMonitorState::Observation::Side::Builder::getStatus() {
  return _builder.getDataField< ::cereal::SpotMonitorState::Observation::Side::Status>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void SpotMonitorState::Observation::Side::Builder::setStatus( ::cereal::SpotMonitorState::Observation::Side::Status value) {
  _builder.setDataField< ::cereal::SpotMonitorState::Observation::Side::Status>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline float SpotMonitorState::Observation::Side::Reader::getConfidence() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline float SpotMonitorState::Observation::Side::Builder::getConfidence() {
  return _builder.getDataField<float>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void SpotMonitorState::Observation::Side::Builder::setConfidence(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline bool SpotMonitorState::Observation::Side::Reader::getWarning() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS);
}

inline bool SpotMonitorState::Observation::Side::Builder::getWarning() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS);
}
inline void SpotMonitorState::Observation::Side::Builder::setWarning(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t SpotMonitorState::Observation::Side::Reader::getSourceFrameId() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SpotMonitorState::Observation::Side::Builder::getSourceFrameId() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void SpotMonitorState::Observation::Side::Builder::setSourceFrameId( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t SpotMonitorState::Observation::Side::Reader::getSourceFrameEofBootTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SpotMonitorState::Observation::Side::Builder::getSourceFrameEofBootTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void SpotMonitorState::Observation::Side::Builder::setSourceFrameEofBootTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t SpotMonitorState::Observation::Side::Reader::getSourceObservedMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SpotMonitorState::Observation::Side::Builder::getSourceObservedMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}
inline void SpotMonitorState::Observation::Side::Builder::setSourceObservedMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t SpotMonitorState::Observation::Side::Reader::getValidUntilBootTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SpotMonitorState::Observation::Side::Builder::getValidUntilBootTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}
inline void SpotMonitorState::Observation::Side::Builder::setValidUntilBootTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotLateralState::Reader::getActive() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline bool StarPilotLateralState::Builder::getActive() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void StarPilotLateralState::Builder::setActive(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline float StarPilotLateralState::Reader::getFrictionThreshold() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline float StarPilotLateralState::Builder::getFrictionThreshold() {
  return _builder.getDataField<float>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void StarPilotLateralState::Builder::setFrictionThreshold(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline float StarPilotLateralState::Reader::getFrictionScale() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline float StarPilotLateralState::Builder::getFrictionScale() {
  return _builder.getDataField<float>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void StarPilotLateralState::Builder::setFrictionScale(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline float StarPilotLateralState::Reader::getFeedforward() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}

inline float StarPilotLateralState::Builder::getFeedforward() {
  return _builder.getDataField<float>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}
inline void StarPilotLateralState::Builder::setFeedforward(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS, value);
}

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

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

inline float StarPilotLateralState::Reader::getFrictionJerkDeadzone() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}

inline float StarPilotLateralState::Builder::getFrictionJerkDeadzone() {
  return _builder.getDataField<float>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}
inline void StarPilotLateralState::Builder::setFrictionJerkDeadzone(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS, value);
}

inline float StarPilotLateralState::Reader::getLowSpeedFactor() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS);
}

inline float StarPilotLateralState::Builder::getLowSpeedFactor() {
  return _builder.getDataField<float>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS);
}
inline void StarPilotLateralState::Builder::setLowSpeedFactor(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotLateralState::Reader::getUnwindDetected() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline bool StarPilotLateralState::Builder::getUnwindDetected() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void StarPilotLateralState::Builder::setUnwindDetected(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotLateralState::Reader::hasLaneCentering() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotLateralState::Builder::hasLaneCentering() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::cereal::StarPilotLateralState::LaneCentering::Reader StarPilotLateralState::Reader::getLaneCentering() const {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotLateralState::LaneCentering>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::cereal::StarPilotLateralState::LaneCentering::Builder StarPilotLateralState::Builder::getLaneCentering() {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotLateralState::LaneCentering>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
#if !CAPNP_LITE
inline  ::cereal::StarPilotLateralState::LaneCentering::Pipeline StarPilotLateralState::Pipeline::getLaneCentering() {
  return  ::cereal::StarPilotLateralState::LaneCentering::Pipeline(_typeless.getPointerField(0));
}
#endif  // !CAPNP_LITE
inline void StarPilotLateralState::Builder::setLaneCentering( ::cereal::StarPilotLateralState::LaneCentering::Reader value) {
  ::capnp::_::PointerHelpers< ::cereal::StarPilotLateralState::LaneCentering>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::cereal::StarPilotLateralState::LaneCentering::Builder StarPilotLateralState::Builder::initLaneCentering() {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotLateralState::LaneCentering>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void StarPilotLateralState::Builder::adoptLaneCentering(
    ::capnp::Orphan< ::cereal::StarPilotLateralState::LaneCentering>&& value) {
  ::capnp::_::PointerHelpers< ::cereal::StarPilotLateralState::LaneCentering>::adopt(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::cereal::StarPilotLateralState::LaneCentering> StarPilotLateralState::Builder::disownLaneCentering() {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotLateralState::LaneCentering>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline bool StarPilotLateralState::Reader::hasLearningEvidence() const {
  return !_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotLateralState::Builder::hasLearningEvidence() {
  return !_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline  ::cereal::LearningControlEvidence::Reader StarPilotLateralState::Reader::getLearningEvidence() const {
  return ::capnp::_::PointerHelpers< ::cereal::LearningControlEvidence>::get(_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline  ::cereal::LearningControlEvidence::Builder StarPilotLateralState::Builder::getLearningEvidence() {
  return ::capnp::_::PointerHelpers< ::cereal::LearningControlEvidence>::get(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
#if !CAPNP_LITE
inline  ::cereal::LearningControlEvidence::Pipeline StarPilotLateralState::Pipeline::getLearningEvidence() {
  return  ::cereal::LearningControlEvidence::Pipeline(_typeless.getPointerField(1));
}
#endif  // !CAPNP_LITE
inline void StarPilotLateralState::Builder::setLearningEvidence( ::cereal::LearningControlEvidence::Reader value) {
  ::capnp::_::PointerHelpers< ::cereal::LearningControlEvidence>::set(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), value);
}
inline  ::cereal::LearningControlEvidence::Builder StarPilotLateralState::Builder::initLearningEvidence() {
  return ::capnp::_::PointerHelpers< ::cereal::LearningControlEvidence>::init(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline void StarPilotLateralState::Builder::adoptLearningEvidence(
    ::capnp::Orphan< ::cereal::LearningControlEvidence>&& value) {
  ::capnp::_::PointerHelpers< ::cereal::LearningControlEvidence>::adopt(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::cereal::LearningControlEvidence> StarPilotLateralState::Builder::disownLearningEvidence() {
  return ::capnp::_::PointerHelpers< ::cereal::LearningControlEvidence>::disown(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}

inline bool StarPilotLateralState::Reader::hasLearningApplication() const {
  return !_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotLateralState::Builder::hasLearningApplication() {
  return !_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline  ::cereal::LearningApplication::Reader StarPilotLateralState::Reader::getLearningApplication() const {
  return ::capnp::_::PointerHelpers< ::cereal::LearningApplication>::get(_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline  ::cereal::LearningApplication::Builder StarPilotLateralState::Builder::getLearningApplication() {
  return ::capnp::_::PointerHelpers< ::cereal::LearningApplication>::get(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
#if !CAPNP_LITE
inline  ::cereal::LearningApplication::Pipeline StarPilotLateralState::Pipeline::getLearningApplication() {
  return  ::cereal::LearningApplication::Pipeline(_typeless.getPointerField(2));
}
#endif  // !CAPNP_LITE
inline void StarPilotLateralState::Builder::setLearningApplication( ::cereal::LearningApplication::Reader value) {
  ::capnp::_::PointerHelpers< ::cereal::LearningApplication>::set(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), value);
}
inline  ::cereal::LearningApplication::Builder StarPilotLateralState::Builder::initLearningApplication() {
  return ::capnp::_::PointerHelpers< ::cereal::LearningApplication>::init(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline void StarPilotLateralState::Builder::adoptLearningApplication(
    ::capnp::Orphan< ::cereal::LearningApplication>&& value) {
  ::capnp::_::PointerHelpers< ::cereal::LearningApplication>::adopt(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::cereal::LearningApplication> StarPilotLateralState::Builder::disownLearningApplication() {
  return ::capnp::_::PointerHelpers< ::cereal::LearningApplication>::disown(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}

inline bool StarPilotLateralState::Reader::hasFeedbackConsumption() const {
  return !_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotLateralState::Builder::hasFeedbackConsumption() {
  return !_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline  ::cereal::StarPilotLateralState::FeedbackConsumption::Reader StarPilotLateralState::Reader::getFeedbackConsumption() const {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotLateralState::FeedbackConsumption>::get(_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline  ::cereal::StarPilotLateralState::FeedbackConsumption::Builder StarPilotLateralState::Builder::getFeedbackConsumption() {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotLateralState::FeedbackConsumption>::get(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
#if !CAPNP_LITE
inline  ::cereal::StarPilotLateralState::FeedbackConsumption::Pipeline StarPilotLateralState::Pipeline::getFeedbackConsumption() {
  return  ::cereal::StarPilotLateralState::FeedbackConsumption::Pipeline(_typeless.getPointerField(3));
}
#endif  // !CAPNP_LITE
inline void StarPilotLateralState::Builder::setFeedbackConsumption( ::cereal::StarPilotLateralState::FeedbackConsumption::Reader value) {
  ::capnp::_::PointerHelpers< ::cereal::StarPilotLateralState::FeedbackConsumption>::set(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), value);
}
inline  ::cereal::StarPilotLateralState::FeedbackConsumption::Builder StarPilotLateralState::Builder::initFeedbackConsumption() {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotLateralState::FeedbackConsumption>::init(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline void StarPilotLateralState::Builder::adoptFeedbackConsumption(
    ::capnp::Orphan< ::cereal::StarPilotLateralState::FeedbackConsumption>&& value) {
  ::capnp::_::PointerHelpers< ::cereal::StarPilotLateralState::FeedbackConsumption>::adopt(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::cereal::StarPilotLateralState::FeedbackConsumption> StarPilotLateralState::Builder::disownFeedbackConsumption() {
  return ::capnp::_::PointerHelpers< ::cereal::StarPilotLateralState::FeedbackConsumption>::disown(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}

inline bool StarPilotLateralState::Reader::hasTrackingApplication() const {
  return !_reader.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotLateralState::Builder::hasTrackingApplication() {
  return !_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS).isNull();
}
inline  ::cereal::LiveTrackingApplication::Reader StarPilotLateralState::Reader::getTrackingApplication() const {
  return ::capnp::_::PointerHelpers< ::cereal::LiveTrackingApplication>::get(_reader.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}
inline  ::cereal::LiveTrackingApplication::Builder StarPilotLateralState::Builder::getTrackingApplication() {
  return ::capnp::_::PointerHelpers< ::cereal::LiveTrackingApplication>::get(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}
#if !CAPNP_LITE
inline  ::cereal::LiveTrackingApplication::Pipeline StarPilotLateralState::Pipeline::getTrackingApplication() {
  return  ::cereal::LiveTrackingApplication::Pipeline(_typeless.getPointerField(4));
}
#endif  // !CAPNP_LITE
inline void StarPilotLateralState::Builder::setTrackingApplication( ::cereal::LiveTrackingApplication::Reader value) {
  ::capnp::_::PointerHelpers< ::cereal::LiveTrackingApplication>::set(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), value);
}
inline  ::cereal::LiveTrackingApplication::Builder StarPilotLateralState::Builder::initTrackingApplication() {
  return ::capnp::_::PointerHelpers< ::cereal::LiveTrackingApplication>::init(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}
inline void StarPilotLateralState::Builder::adoptTrackingApplication(
    ::capnp::Orphan< ::cereal::LiveTrackingApplication>&& value) {
  ::capnp::_::PointerHelpers< ::cereal::LiveTrackingApplication>::adopt(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::cereal::LiveTrackingApplication> StarPilotLateralState::Builder::disownTrackingApplication() {
  return ::capnp::_::PointerHelpers< ::cereal::LiveTrackingApplication>::disown(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}

inline  ::uint16_t StarPilotLateralState::LaneCentering::Reader::getVersion() const {
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline  ::uint16_t StarPilotLateralState::LaneCentering::Builder::getVersion() {
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void StarPilotLateralState::LaneCentering::Builder::setVersion( ::uint16_t value) {
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t StarPilotLateralState::LaneCentering::Reader::getModelMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t StarPilotLateralState::LaneCentering::Builder::getModelMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void StarPilotLateralState::LaneCentering::Builder::setModelMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t StarPilotLateralState::LaneCentering::Reader::getCarControlMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t StarPilotLateralState::LaneCentering::Builder::getCarControlMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void StarPilotLateralState::LaneCentering::Builder::setCarControlMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotLateralState::LaneCentering::Reader::getLateralActive() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS);
}

inline bool StarPilotLateralState::LaneCentering::Builder::getLateralActive() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS);
}
inline void StarPilotLateralState::LaneCentering::Builder::setLateralActive(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS, value);
}

inline float StarPilotLateralState::LaneCentering::Reader::getRequestedCorrection() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline float StarPilotLateralState::LaneCentering::Builder::getRequestedCorrection() {
  return _builder.getDataField<float>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void StarPilotLateralState::LaneCentering::Builder::setRequestedCorrection(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline float StarPilotLateralState::LaneCentering::Reader::getAppliedCorrection() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS);
}

inline float StarPilotLateralState::LaneCentering::Builder::getAppliedCorrection() {
  return _builder.getDataField<float>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS);
}
inline void StarPilotLateralState::LaneCentering::Builder::setAppliedCorrection(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotLateralState::LaneCentering::Reader::hasReason() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotLateralState::LaneCentering::Builder::hasReason() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader StarPilotLateralState::LaneCentering::Reader::getReason() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder StarPilotLateralState::LaneCentering::Builder::getReason() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void StarPilotLateralState::LaneCentering::Builder::setReason( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder StarPilotLateralState::LaneCentering::Builder::initReason(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void StarPilotLateralState::LaneCentering::Builder::adoptReason(
    ::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> StarPilotLateralState::LaneCentering::Builder::disownReason() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline  ::uint16_t StarPilotLateralState::FeedbackConsumption::Reader::getVersion() const {
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline  ::uint16_t StarPilotLateralState::FeedbackConsumption::Builder::getVersion() {
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void StarPilotLateralState::FeedbackConsumption::Builder::setVersion( ::uint16_t value) {
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t StarPilotLateralState::FeedbackConsumption::Reader::getControlMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t StarPilotLateralState::FeedbackConsumption::Builder::getControlMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void StarPilotLateralState::FeedbackConsumption::Builder::setControlMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t StarPilotLateralState::FeedbackConsumption::Reader::getConsumedPublicationMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t StarPilotLateralState::FeedbackConsumption::Builder::getConsumedPublicationMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void StarPilotLateralState::FeedbackConsumption::Builder::setConsumedPublicationMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t StarPilotLateralState::FeedbackConsumption::Reader::getConsumedRecvFrame() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t StarPilotLateralState::FeedbackConsumption::Builder::getConsumedRecvFrame() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}
inline void StarPilotLateralState::FeedbackConsumption::Builder::setConsumedRecvFrame( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t StarPilotLateralState::FeedbackConsumption::Reader::getConsumedReceiptMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t StarPilotLateralState::FeedbackConsumption::Builder::getConsumedReceiptMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}
inline void StarPilotLateralState::FeedbackConsumption::Builder::setConsumedReceiptMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotLateralState::FeedbackConsumption::Reader::getConsumedSeen() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS);
}

inline bool StarPilotLateralState::FeedbackConsumption::Builder::getConsumedSeen() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS);
}
inline void StarPilotLateralState::FeedbackConsumption::Builder::setConsumedSeen(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotLateralState::FeedbackConsumption::Reader::getConsumedValid() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<17>() * ::capnp::ELEMENTS);
}

inline bool StarPilotLateralState::FeedbackConsumption::Builder::getConsumedValid() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<17>() * ::capnp::ELEMENTS);
}
inline void StarPilotLateralState::FeedbackConsumption::Builder::setConsumedValid(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<17>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotLateralState::FeedbackConsumption::Reader::hasCoBodySha256() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotLateralState::FeedbackConsumption::Builder::hasCoBodySha256() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Data::Reader StarPilotLateralState::FeedbackConsumption::Reader::getCoBodySha256() const {
  return ::capnp::_::PointerHelpers< ::capnp::Data>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::capnp::Data::Builder StarPilotLateralState::FeedbackConsumption::Builder::getCoBodySha256() {
  return ::capnp::_::PointerHelpers< ::capnp::Data>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void StarPilotLateralState::FeedbackConsumption::Builder::setCoBodySha256( ::capnp::Data::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Data>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Data::Builder StarPilotLateralState::FeedbackConsumption::Builder::initCoBodySha256(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Data>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void StarPilotLateralState::FeedbackConsumption::Builder::adoptCoBodySha256(
    ::capnp::Orphan< ::capnp::Data>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Data>::adopt(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Data> StarPilotLateralState::FeedbackConsumption::Builder::disownCoBodySha256() {
  return ::capnp::_::PointerHelpers< ::capnp::Data>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline float StarPilotLateralState::FeedbackConsumption::Reader::getReportedTorque() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline float StarPilotLateralState::FeedbackConsumption::Builder::getReportedTorque() {
  return _builder.getDataField<float>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void StarPilotLateralState::FeedbackConsumption::Builder::setReportedTorque(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline float StarPilotLateralState::FeedbackConsumption::Reader::getRequestTorque() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<10>() * ::capnp::ELEMENTS);
}

inline float StarPilotLateralState::FeedbackConsumption::Builder::getRequestTorque() {
  return _builder.getDataField<float>(
      ::capnp::bounded<10>() * ::capnp::ELEMENTS);
}
inline void StarPilotLateralState::FeedbackConsumption::Builder::setRequestTorque(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<10>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotLateralState::FeedbackConsumption::Reader::getLatActive() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<18>() * ::capnp::ELEMENTS);
}

inline bool StarPilotLateralState::FeedbackConsumption::Builder::getLatActive() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<18>() * ::capnp::ELEMENTS);
}
inline void StarPilotLateralState::FeedbackConsumption::Builder::setLatActive(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<18>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotLateralState::FeedbackConsumption::Reader::getInputSafetyLimited() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<19>() * ::capnp::ELEMENTS);
}

inline bool StarPilotLateralState::FeedbackConsumption::Builder::getInputSafetyLimited() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<19>() * ::capnp::ELEMENTS);
}
inline void StarPilotLateralState::FeedbackConsumption::Builder::setInputSafetyLimited(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<19>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotLateralState::FeedbackConsumption::Reader::getPublishedSafetyLimited() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<20>() * ::capnp::ELEMENTS);
}

inline bool StarPilotLateralState::FeedbackConsumption::Builder::getPublishedSafetyLimited() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<20>() * ::capnp::ELEMENTS);
}
inline void StarPilotLateralState::FeedbackConsumption::Builder::setPublishedSafetyLimited(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<20>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t StarPilotLateralState::FeedbackConsumption::Reader::getPriorPublishControlMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t StarPilotLateralState::FeedbackConsumption::Builder::getPriorPublishControlMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS);
}
inline void StarPilotLateralState::FeedbackConsumption::Builder::setPriorPublishControlMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS, value);
}

inline bool StarPilotLateralState::FeedbackConsumption::Reader::hasSourceEpoch() const {
  return !_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotLateralState::FeedbackConsumption::Builder::hasSourceEpoch() {
  return !_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader StarPilotLateralState::FeedbackConsumption::Reader::getSourceEpoch() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder StarPilotLateralState::FeedbackConsumption::Builder::getSourceEpoch() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline void StarPilotLateralState::FeedbackConsumption::Builder::setSourceEpoch( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder StarPilotLateralState::FeedbackConsumption::Builder::initSourceEpoch(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), size);
}
inline void StarPilotLateralState::FeedbackConsumption::Builder::adoptSourceEpoch(
    ::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> StarPilotLateralState::FeedbackConsumption::Builder::disownSourceEpoch() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}

inline bool StarPilotLateralState::FeedbackConsumption::Reader::hasCpSha256() const {
  return !_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline bool StarPilotLateralState::FeedbackConsumption::Builder::hasCpSha256() {
  return !_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader StarPilotLateralState::FeedbackConsumption::Reader::getCpSha256() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder StarPilotLateralState::FeedbackConsumption::Builder::getCpSha256() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline void StarPilotLateralState::FeedbackConsumption::Builder::setCpSha256( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder StarPilotLateralState::FeedbackConsumption::Builder::initCpSha256(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), size);
}
inline void StarPilotLateralState::FeedbackConsumption::Builder::adoptCpSha256(
    ::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> StarPilotLateralState::FeedbackConsumption::Builder::disownCpSha256() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}

inline  ::cereal::SlcCruiseCommand::Kind SlcCruiseCommand::Reader::getKind() const {
  return _reader.getDataField< ::cereal::SlcCruiseCommand::Kind>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline  ::cereal::SlcCruiseCommand::Kind SlcCruiseCommand::Builder::getKind() {
  return _builder.getDataField< ::cereal::SlcCruiseCommand::Kind>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void SlcCruiseCommand::Builder::setKind( ::cereal::SlcCruiseCommand::Kind value) {
  _builder.setDataField< ::cereal::SlcCruiseCommand::Kind>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool SlcCruiseCommand::Reader::hasSessionId() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool SlcCruiseCommand::Builder::hasSessionId() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader SlcCruiseCommand::Reader::getSessionId() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder SlcCruiseCommand::Builder::getSessionId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void SlcCruiseCommand::Builder::setSessionId( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder SlcCruiseCommand::Builder::initSessionId(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void SlcCruiseCommand::Builder::adoptSessionId(
    ::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> SlcCruiseCommand::Builder::disownSessionId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline  ::uint64_t SlcCruiseCommand::Reader::getCommandId() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcCruiseCommand::Builder::getCommandId() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void SlcCruiseCommand::Builder::setCommandId( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t SlcCruiseCommand::Reader::getActionId() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcCruiseCommand::Builder::getActionId() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void SlcCruiseCommand::Builder::setActionId( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t SlcCruiseCommand::Reader::getDecisionId() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcCruiseCommand::Builder::getDecisionId() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}
inline void SlcCruiseCommand::Builder::setDecisionId( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t SlcCruiseCommand::Reader::getPresentationId() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcCruiseCommand::Builder::getPresentationId() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}
inline void SlcCruiseCommand::Builder::setPresentationId( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS, value);
}

inline bool SlcCruiseCommand::Reader::hasSourceProducerSessionId() const {
  return !_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline bool SlcCruiseCommand::Builder::hasSourceProducerSessionId() {
  return !_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader SlcCruiseCommand::Reader::getSourceProducerSessionId() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder SlcCruiseCommand::Builder::getSourceProducerSessionId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline void SlcCruiseCommand::Builder::setSourceProducerSessionId( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder SlcCruiseCommand::Builder::initSourceProducerSessionId(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), size);
}
inline void SlcCruiseCommand::Builder::adoptSourceProducerSessionId(
    ::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> SlcCruiseCommand::Builder::disownSourceProducerSessionId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}

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

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

inline  ::uint64_t SlcCruiseCommand::Reader::getSourceObservedMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcCruiseCommand::Builder::getSourceObservedMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}
inline void SlcCruiseCommand::Builder::setSourceObservedMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t SlcCruiseCommand::Reader::getSourceValidUntilMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcCruiseCommand::Builder::getSourceValidUntilMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS);
}
inline void SlcCruiseCommand::Builder::setSourceValidUntilMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t SlcCruiseCommand::Reader::getIssuedMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<7>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcCruiseCommand::Builder::getIssuedMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<7>() * ::capnp::ELEMENTS);
}
inline void SlcCruiseCommand::Builder::setIssuedMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<7>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t SlcCruiseCommand::Reader::getExpiresMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<8>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t SlcCruiseCommand::Builder::getExpiresMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<8>() * ::capnp::ELEMENTS);
}
inline void SlcCruiseCommand::Builder::setExpiresMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<8>() * ::capnp::ELEMENTS, value);
}

inline float SlcCruiseCommand::Reader::getExpectedSelectedMps() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<18>() * ::capnp::ELEMENTS);
}

inline float SlcCruiseCommand::Builder::getExpectedSelectedMps() {
  return _builder.getDataField<float>(
      ::capnp::bounded<18>() * ::capnp::ELEMENTS);
}
inline void SlcCruiseCommand::Builder::setExpectedSelectedMps(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<18>() * ::capnp::ELEMENTS, value);
}

inline float SlcCruiseCommand::Reader::getTargetMps() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<19>() * ::capnp::ELEMENTS);
}

inline float SlcCruiseCommand::Builder::getTargetMps() {
  return _builder.getDataField<float>(
      ::capnp::bounded<19>() * ::capnp::ELEMENTS);
}
inline void SlcCruiseCommand::Builder::setTargetMps(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<19>() * ::capnp::ELEMENTS, value);
}

inline bool SlcCruiseCommand::Reader::hasSource() const {
  return !_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline bool SlcCruiseCommand::Builder::hasSource() {
  return !_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader SlcCruiseCommand::Reader::getSource() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder SlcCruiseCommand::Builder::getSource() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline void SlcCruiseCommand::Builder::setSource( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder SlcCruiseCommand::Builder::initSource(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), size);
}
inline void SlcCruiseCommand::Builder::adoptSource(
    ::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> SlcCruiseCommand::Builder::disownSource() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}

inline bool AolAxisState::Reader::hasSessionId() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool AolAxisState::Builder::hasSessionId() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader AolAxisState::Reader::getSessionId() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder AolAxisState::Builder::getSessionId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void AolAxisState::Builder::setSessionId( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder AolAxisState::Builder::initSessionId(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void AolAxisState::Builder::adoptSessionId(
    ::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> AolAxisState::Builder::disownSessionId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline  ::uint64_t AolAxisState::Reader::getSequence() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

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

inline  ::uint64_t AolAxisState::Reader::getSourceCarStateMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t AolAxisState::Builder::getSourceCarStateMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void AolAxisState::Builder::setSourceCarStateMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t AolAxisState::Reader::getObservedMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t AolAxisState::Builder::getObservedMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void AolAxisState::Builder::setObservedMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t AolAxisState::Reader::getValidUntilMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t AolAxisState::Builder::getValidUntilMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}
inline void AolAxisState::Builder::setValidUntilMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS, value);
}

inline  ::cereal::AolAxisState::Mode AolAxisState::Reader::getMode() const {
  return _reader.getDataField< ::cereal::AolAxisState::Mode>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS);
}

inline  ::cereal::AolAxisState::Mode AolAxisState::Builder::getMode() {
  return _builder.getDataField< ::cereal::AolAxisState::Mode>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS);
}
inline void AolAxisState::Builder::setMode( ::cereal::AolAxisState::Mode value) {
  _builder.setDataField< ::cereal::AolAxisState::Mode>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS, value);
}

inline bool AolAxisState::Reader::getLateralActive() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<272>() * ::capnp::ELEMENTS);
}

inline bool AolAxisState::Builder::getLateralActive() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<272>() * ::capnp::ELEMENTS);
}
inline void AolAxisState::Builder::setLateralActive(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<272>() * ::capnp::ELEMENTS, value);
}

inline bool AolAxisState::Reader::getLongitudinalActive() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<273>() * ::capnp::ELEMENTS);
}

inline bool AolAxisState::Builder::getLongitudinalActive() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<273>() * ::capnp::ELEMENTS);
}
inline void AolAxisState::Builder::setLongitudinalActive(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<273>() * ::capnp::ELEMENTS, value);
}

inline bool AolAxisState::Reader::getQualified() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<274>() * ::capnp::ELEMENTS);
}

inline bool AolAxisState::Builder::getQualified() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<274>() * ::capnp::ELEMENTS);
}
inline void AolAxisState::Builder::setQualified(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<274>() * ::capnp::ELEMENTS, value);
}

inline bool AolAxisState::Reader::getDesiredLateral() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<275>() * ::capnp::ELEMENTS);
}

inline bool AolAxisState::Builder::getDesiredLateral() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<275>() * ::capnp::ELEMENTS);
}
inline void AolAxisState::Builder::setDesiredLateral(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<275>() * ::capnp::ELEMENTS, value);
}

inline bool AolAxisState::Reader::getDesiredLongitudinal() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<276>() * ::capnp::ELEMENTS);
}

inline bool AolAxisState::Builder::getDesiredLongitudinal() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<276>() * ::capnp::ELEMENTS);
}
inline void AolAxisState::Builder::setDesiredLongitudinal(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<276>() * ::capnp::ELEMENTS, value);
}

inline bool AolAxisState::Reader::getNativeAcknowledged() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<277>() * ::capnp::ELEMENTS);
}

inline bool AolAxisState::Builder::getNativeAcknowledged() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<277>() * ::capnp::ELEMENTS);
}
inline void AolAxisState::Builder::setNativeAcknowledged(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<277>() * ::capnp::ELEMENTS, value);
}

inline bool AolAxisState::Reader::getOptionalSetRelease() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<278>() * ::capnp::ELEMENTS);
}

inline bool AolAxisState::Builder::getOptionalSetRelease() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<278>() * ::capnp::ELEMENTS);
}
inline void AolAxisState::Builder::setOptionalSetRelease(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<278>() * ::capnp::ELEMENTS, value);
}

inline  ::cereal::AolAxisState::FaultReason AolAxisState::Reader::getFaultReason() const {
  return _reader.getDataField< ::cereal::AolAxisState::FaultReason>(
      ::capnp::bounded<18>() * ::capnp::ELEMENTS);
}

inline  ::cereal::AolAxisState::FaultReason AolAxisState::Builder::getFaultReason() {
  return _builder.getDataField< ::cereal::AolAxisState::FaultReason>(
      ::capnp::bounded<18>() * ::capnp::ELEMENTS);
}
inline void AolAxisState::Builder::setFaultReason( ::cereal::AolAxisState::FaultReason value) {
  _builder.setDataField< ::cereal::AolAxisState::FaultReason>(
      ::capnp::bounded<18>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t AolAxisState::Reader::getFaultEventMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t AolAxisState::Builder::getFaultEventMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}
inline void AolAxisState::Builder::setFaultEventMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS, value);
}

inline bool AolAxisState::Reader::hasFaultSessionId() const {
  return !_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline bool AolAxisState::Builder::hasFaultSessionId() {
  return !_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader AolAxisState::Reader::getFaultSessionId() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder AolAxisState::Builder::getFaultSessionId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline void AolAxisState::Builder::setFaultSessionId( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder AolAxisState::Builder::initFaultSessionId(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), size);
}
inline void AolAxisState::Builder::adoptFaultSessionId(
    ::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> AolAxisState::Builder::disownFaultSessionId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}

inline bool AolAxisState::Reader::hasIntentProducerSessionId() const {
  return !_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline bool AolAxisState::Builder::hasIntentProducerSessionId() {
  return !_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader AolAxisState::Reader::getIntentProducerSessionId() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder AolAxisState::Builder::getIntentProducerSessionId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline void AolAxisState::Builder::setIntentProducerSessionId( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder AolAxisState::Builder::initIntentProducerSessionId(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), size);
}
inline void AolAxisState::Builder::adoptIntentProducerSessionId(
    ::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> AolAxisState::Builder::disownIntentProducerSessionId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}

inline  ::uint64_t AolAxisState::Reader::getIntentIntegrityEpoch() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t AolAxisState::Builder::getIntentIntegrityEpoch() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS);
}
inline void AolAxisState::Builder::setIntentIntegrityEpoch( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS, value);
}

inline  ::uint8_t AolAxisState::SafetyWire::Reader::getKind() const {
  return _reader.getDataField< ::uint8_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline  ::uint8_t AolAxisState::SafetyWire::Builder::getKind() {
  return _builder.getDataField< ::uint8_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void AolAxisState::SafetyWire::Builder::setKind( ::uint8_t value) {
  _builder.setDataField< ::uint8_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline  ::uint16_t AolAxisState::SafetyWire::Reader::getVersion() const {
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline  ::uint16_t AolAxisState::SafetyWire::Builder::getVersion() {
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void AolAxisState::SafetyWire::Builder::setVersion( ::uint16_t value) {
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline  ::uint16_t AolAxisState::SafetyWire::Reader::getProtocolVersion() const {
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline  ::uint16_t AolAxisState::SafetyWire::Builder::getProtocolVersion() {
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void AolAxisState::SafetyWire::Builder::setProtocolVersion( ::uint16_t value) {
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline bool AolAxisState::SafetyWire::Reader::getCompatible() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<8>() * ::capnp::ELEMENTS);
}

inline bool AolAxisState::SafetyWire::Builder::getCompatible() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<8>() * ::capnp::ELEMENTS);
}
inline void AolAxisState::SafetyWire::Builder::setCompatible(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<8>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t AolAxisState::SafetyWire::Reader::getObservedMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t AolAxisState::SafetyWire::Builder::getObservedMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void AolAxisState::SafetyWire::Builder::setObservedMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t AolAxisState::SafetyWire::Reader::getValidUntilMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t AolAxisState::SafetyWire::Builder::getValidUntilMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void AolAxisState::SafetyWire::Builder::setValidUntilMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline  ::uint16_t AolAxisState::SafetyWire::Reader::getSafetyModel() const {
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}

inline  ::uint16_t AolAxisState::SafetyWire::Builder::getSafetyModel() {
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}
inline void AolAxisState::SafetyWire::Builder::setSafetyModel( ::uint16_t value) {
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS, value);
}

inline  ::uint16_t AolAxisState::SafetyWire::Reader::getSafetyParam() const {
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<12>() * ::capnp::ELEMENTS);
}

inline  ::uint16_t AolAxisState::SafetyWire::Builder::getSafetyParam() {
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<12>() * ::capnp::ELEMENTS);
}
inline void AolAxisState::SafetyWire::Builder::setSafetyParam( ::uint16_t value) {
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<12>() * ::capnp::ELEMENTS, value);
}

inline bool AolAxisState::SafetyWire::Reader::getLateralAllowed() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<9>() * ::capnp::ELEMENTS);
}

inline bool AolAxisState::SafetyWire::Builder::getLateralAllowed() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<9>() * ::capnp::ELEMENTS);
}
inline void AolAxisState::SafetyWire::Builder::setLateralAllowed(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<9>() * ::capnp::ELEMENTS, value);
}

inline bool AolAxisState::SafetyWire::Reader::getLongitudinalAllowed() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<10>() * ::capnp::ELEMENTS);
}

inline bool AolAxisState::SafetyWire::Builder::getLongitudinalAllowed() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<10>() * ::capnp::ELEMENTS);
}
inline void AolAxisState::SafetyWire::Builder::setLongitudinalAllowed(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<10>() * ::capnp::ELEMENTS, value);
}

inline bool AolAxisState::SafetyWire::Reader::getRequestedLateral() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<11>() * ::capnp::ELEMENTS);
}

inline bool AolAxisState::SafetyWire::Builder::getRequestedLateral() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<11>() * ::capnp::ELEMENTS);
}
inline void AolAxisState::SafetyWire::Builder::setRequestedLateral(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<11>() * ::capnp::ELEMENTS, value);
}

inline bool AolAxisState::SafetyWire::Reader::getRequestedLongitudinal() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<12>() * ::capnp::ELEMENTS);
}

inline bool AolAxisState::SafetyWire::Builder::getRequestedLongitudinal() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<12>() * ::capnp::ELEMENTS);
}
inline void AolAxisState::SafetyWire::Builder::setRequestedLongitudinal(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<12>() * ::capnp::ELEMENTS, value);
}

inline bool AolAxisState::SafetyWire::Reader::hasPandaSerial() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool AolAxisState::SafetyWire::Builder::hasPandaSerial() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader AolAxisState::SafetyWire::Reader::getPandaSerial() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder AolAxisState::SafetyWire::Builder::getPandaSerial() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void AolAxisState::SafetyWire::Builder::setPandaSerial( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder AolAxisState::SafetyWire::Builder::initPandaSerial(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void AolAxisState::SafetyWire::Builder::adoptPandaSerial(
    ::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> AolAxisState::SafetyWire::Builder::disownPandaSerial() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline bool AolAxisState::SafetyWire::Reader::hasAxisSessionId() const {
  return !_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline bool AolAxisState::SafetyWire::Builder::hasAxisSessionId() {
  return !_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader AolAxisState::SafetyWire::Reader::getAxisSessionId() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder AolAxisState::SafetyWire::Builder::getAxisSessionId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline void AolAxisState::SafetyWire::Builder::setAxisSessionId( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder AolAxisState::SafetyWire::Builder::initAxisSessionId(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), size);
}
inline void AolAxisState::SafetyWire::Builder::adoptAxisSessionId(
    ::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> AolAxisState::SafetyWire::Builder::disownAxisSessionId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}

inline  ::uint64_t AolAxisState::SafetyWire::Reader::getSourcePandaStatesMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t AolAxisState::SafetyWire::Builder::getSourcePandaStatesMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}
inline void AolAxisState::SafetyWire::Builder::setSourcePandaStatesMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS, value);
}

inline bool AolAxisState::SafetyWire::Reader::hasPandaInventory() const {
  return !_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline bool AolAxisState::SafetyWire::Builder::hasPandaInventory() {
  return !_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::List< ::cereal::AolAxisState::SafetyWire::PandaSlot,  ::capnp::Kind::STRUCT>::Reader AolAxisState::SafetyWire::Reader::getPandaInventory() const {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::AolAxisState::SafetyWire::PandaSlot,  ::capnp::Kind::STRUCT>>::get(_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline  ::capnp::List< ::cereal::AolAxisState::SafetyWire::PandaSlot,  ::capnp::Kind::STRUCT>::Builder AolAxisState::SafetyWire::Builder::getPandaInventory() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::AolAxisState::SafetyWire::PandaSlot,  ::capnp::Kind::STRUCT>>::get(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline void AolAxisState::SafetyWire::Builder::setPandaInventory( ::capnp::List< ::cereal::AolAxisState::SafetyWire::PandaSlot,  ::capnp::Kind::STRUCT>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::AolAxisState::SafetyWire::PandaSlot,  ::capnp::Kind::STRUCT>>::set(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), value);
}
inline  ::capnp::List< ::cereal::AolAxisState::SafetyWire::PandaSlot,  ::capnp::Kind::STRUCT>::Builder AolAxisState::SafetyWire::Builder::initPandaInventory(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::AolAxisState::SafetyWire::PandaSlot,  ::capnp::Kind::STRUCT>>::init(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), size);
}
inline void AolAxisState::SafetyWire::Builder::adoptPandaInventory(
    ::capnp::Orphan< ::capnp::List< ::cereal::AolAxisState::SafetyWire::PandaSlot,  ::capnp::Kind::STRUCT>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::AolAxisState::SafetyWire::PandaSlot,  ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List< ::cereal::AolAxisState::SafetyWire::PandaSlot,  ::capnp::Kind::STRUCT>> AolAxisState::SafetyWire::Builder::disownPandaInventory() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::AolAxisState::SafetyWire::PandaSlot,  ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}

inline  ::uint16_t AolAxisState::SafetyWire::PandaSlot::Reader::getSlotIndex() const {
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline  ::uint16_t AolAxisState::SafetyWire::PandaSlot::Builder::getSlotIndex() {
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void AolAxisState::SafetyWire::PandaSlot::Builder::setSlotIndex( ::uint16_t value) {
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool AolAxisState::SafetyWire::PandaSlot::Reader::hasHardwareSerial() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool AolAxisState::SafetyWire::PandaSlot::Builder::hasHardwareSerial() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader AolAxisState::SafetyWire::PandaSlot::Reader::getHardwareSerial() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder AolAxisState::SafetyWire::PandaSlot::Builder::getHardwareSerial() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void AolAxisState::SafetyWire::PandaSlot::Builder::setHardwareSerial( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder AolAxisState::SafetyWire::PandaSlot::Builder::initHardwareSerial(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void AolAxisState::SafetyWire::PandaSlot::Builder::adoptHardwareSerial(
    ::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> AolAxisState::SafetyWire::PandaSlot::Builder::disownHardwareSerial() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline  ::uint16_t AolAxisState::SafetyWire::PandaSlot::Reader::getSafetyModel() const {
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline  ::uint16_t AolAxisState::SafetyWire::PandaSlot::Builder::getSafetyModel() {
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void AolAxisState::SafetyWire::PandaSlot::Builder::setSafetyModel( ::uint16_t value) {
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline  ::uint16_t AolAxisState::SafetyWire::PandaSlot::Reader::getSafetyParam() const {
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline  ::uint16_t AolAxisState::SafetyWire::PandaSlot::Builder::getSafetyParam() {
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void AolAxisState::SafetyWire::PandaSlot::Builder::setSafetyParam( ::uint16_t value) {
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline  ::uint16_t AolAxisState::SafetyWire::PandaSlot::Reader::getAlternativeExperience() const {
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}

inline  ::uint16_t AolAxisState::SafetyWire::PandaSlot::Builder::getAlternativeExperience() {
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}
inline void AolAxisState::SafetyWire::PandaSlot::Builder::setAlternativeExperience( ::uint16_t value) {
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS, value);
}

inline bool AolAxisState::SafetyWire::PandaSlot::Reader::getControlsAllowed() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<64>() * ::capnp::ELEMENTS);
}

inline bool AolAxisState::SafetyWire::PandaSlot::Builder::getControlsAllowed() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<64>() * ::capnp::ELEMENTS);
}
inline void AolAxisState::SafetyWire::PandaSlot::Builder::setControlsAllowed(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<64>() * ::capnp::ELEMENTS, value);
}

inline bool AolAxisState::SafetyWire::PandaSlot::Reader::getSafetyRxChecksInvalid() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<65>() * ::capnp::ELEMENTS);
}

inline bool AolAxisState::SafetyWire::PandaSlot::Builder::getSafetyRxChecksInvalid() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<65>() * ::capnp::ELEMENTS);
}
inline void AolAxisState::SafetyWire::PandaSlot::Builder::setSafetyRxChecksInvalid(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<65>() * ::capnp::ELEMENTS, value);
}

inline bool AolAxisState::SafetyWire::PandaSlot::Reader::getHeartbeatLost() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<66>() * ::capnp::ELEMENTS);
}

inline bool AolAxisState::SafetyWire::PandaSlot::Builder::getHeartbeatLost() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<66>() * ::capnp::ELEMENTS);
}
inline void AolAxisState::SafetyWire::PandaSlot::Builder::setHeartbeatLost(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<66>() * ::capnp::ELEMENTS, value);
}

inline  ::uint32_t AolAxisState::SafetyWire::PandaSlot::Reader::getFaults() const {
  return _reader.getDataField< ::uint32_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}

inline  ::uint32_t AolAxisState::SafetyWire::PandaSlot::Builder::getFaults() {
  return _builder.getDataField< ::uint32_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}
inline void AolAxisState::SafetyWire::PandaSlot::Builder::setFaults( ::uint32_t value) {
  _builder.setDataField< ::uint32_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS, value);
}

inline  ::uint8_t AolAxisState::IntentWire::Reader::getKind() const {
  return _reader.getDataField< ::uint8_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline  ::uint8_t AolAxisState::IntentWire::Builder::getKind() {
  return _builder.getDataField< ::uint8_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void AolAxisState::IntentWire::Builder::setKind( ::uint8_t value) {
  _builder.setDataField< ::uint8_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline  ::uint16_t AolAxisState::IntentWire::Reader::getVersion() const {
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline  ::uint16_t AolAxisState::IntentWire::Builder::getVersion() {
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void AolAxisState::IntentWire::Builder::setVersion( ::uint16_t value) {
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline bool AolAxisState::IntentWire::Reader::hasProducerSessionId() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool AolAxisState::IntentWire::Builder::hasProducerSessionId() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader AolAxisState::IntentWire::Reader::getProducerSessionId() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder AolAxisState::IntentWire::Builder::getProducerSessionId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void AolAxisState::IntentWire::Builder::setProducerSessionId( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder AolAxisState::IntentWire::Builder::initProducerSessionId(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void AolAxisState::IntentWire::Builder::adoptProducerSessionId(
    ::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> AolAxisState::IntentWire::Builder::disownProducerSessionId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline  ::uint64_t AolAxisState::IntentWire::Reader::getSequence() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t AolAxisState::IntentWire::Builder::getSequence() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void AolAxisState::IntentWire::Builder::setSequence( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t AolAxisState::IntentWire::Reader::getCarStateLogMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t AolAxisState::IntentWire::Builder::getCarStateLogMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void AolAxisState::IntentWire::Builder::setCarStateLogMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t AolAxisState::IntentWire::Reader::getObservedMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t AolAxisState::IntentWire::Builder::getObservedMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}
inline void AolAxisState::IntentWire::Builder::setObservedMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t AolAxisState::IntentWire::Reader::getValidUntilMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t AolAxisState::IntentWire::Builder::getValidUntilMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}
inline void AolAxisState::IntentWire::Builder::setValidUntilMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS, value);
}

inline bool AolAxisState::IntentWire::Reader::getAllowedLatch() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<8>() * ::capnp::ELEMENTS);
}

inline bool AolAxisState::IntentWire::Builder::getAllowedLatch() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<8>() * ::capnp::ELEMENTS);
}
inline void AolAxisState::IntentWire::Builder::setAllowedLatch(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<8>() * ::capnp::ELEMENTS, value);
}

inline bool AolAxisState::IntentWire::Reader::getPauseLateral() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<9>() * ::capnp::ELEMENTS);
}

inline bool AolAxisState::IntentWire::Builder::getPauseLateral() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<9>() * ::capnp::ELEMENTS);
}
inline void AolAxisState::IntentWire::Builder::setPauseLateral(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<9>() * ::capnp::ELEMENTS, value);
}

inline bool AolAxisState::IntentWire::Reader::getPauseLongitudinal() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<10>() * ::capnp::ELEMENTS);
}

inline bool AolAxisState::IntentWire::Builder::getPauseLongitudinal() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<10>() * ::capnp::ELEMENTS);
}
inline void AolAxisState::IntentWire::Builder::setPauseLongitudinal(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<10>() * ::capnp::ELEMENTS, value);
}

inline bool AolAxisState::IntentWire::Reader::getSettingsQualified() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<11>() * ::capnp::ELEMENTS);
}

inline bool AolAxisState::IntentWire::Builder::getSettingsQualified() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<11>() * ::capnp::ELEMENTS);
}
inline void AolAxisState::IntentWire::Builder::setSettingsQualified(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<11>() * ::capnp::ELEMENTS, value);
}

inline bool AolAxisState::IntentWire::Reader::getLateralArmed() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<12>() * ::capnp::ELEMENTS);
}

inline bool AolAxisState::IntentWire::Builder::getLateralArmed() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<12>() * ::capnp::ELEMENTS);
}
inline void AolAxisState::IntentWire::Builder::setLateralArmed(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<12>() * ::capnp::ELEMENTS, value);
}

inline bool AolAxisState::IntentWire::Reader::getOptionalSetRelease() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<13>() * ::capnp::ELEMENTS);
}

inline bool AolAxisState::IntentWire::Builder::getOptionalSetRelease() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<13>() * ::capnp::ELEMENTS);
}
inline void AolAxisState::IntentWire::Builder::setOptionalSetRelease(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<13>() * ::capnp::ELEMENTS, value);
}

inline  ::uint8_t AolAxisState::LaneChangeStatusWire::Reader::getKind() const {
  return _reader.getDataField< ::uint8_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline  ::uint8_t AolAxisState::LaneChangeStatusWire::Builder::getKind() {
  return _builder.getDataField< ::uint8_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void AolAxisState::LaneChangeStatusWire::Builder::setKind( ::uint8_t value) {
  _builder.setDataField< ::uint8_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline  ::uint16_t AolAxisState::LaneChangeStatusWire::Reader::getVersion() const {
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline  ::uint16_t AolAxisState::LaneChangeStatusWire::Builder::getVersion() {
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void AolAxisState::LaneChangeStatusWire::Builder::setVersion( ::uint16_t value) {
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline bool AolAxisState::LaneChangeStatusWire::Reader::hasProducerSessionId() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool AolAxisState::LaneChangeStatusWire::Builder::hasProducerSessionId() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader AolAxisState::LaneChangeStatusWire::Reader::getProducerSessionId() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder AolAxisState::LaneChangeStatusWire::Builder::getProducerSessionId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void AolAxisState::LaneChangeStatusWire::Builder::setProducerSessionId( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder AolAxisState::LaneChangeStatusWire::Builder::initProducerSessionId(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void AolAxisState::LaneChangeStatusWire::Builder::adoptProducerSessionId(
    ::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> AolAxisState::LaneChangeStatusWire::Builder::disownProducerSessionId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline  ::uint64_t AolAxisState::LaneChangeStatusWire::Reader::getSequence() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t AolAxisState::LaneChangeStatusWire::Builder::getSequence() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void AolAxisState::LaneChangeStatusWire::Builder::setSequence( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

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

inline  ::uint32_t AolAxisState::LaneChangeStatusWire::Builder::getModelFrameId() {
  return _builder.getDataField< ::uint32_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void AolAxisState::LaneChangeStatusWire::Builder::setModelFrameId( ::uint32_t value) {
  _builder.setDataField< ::uint32_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t AolAxisState::LaneChangeStatusWire::Reader::getModelTimestampEofNs() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t AolAxisState::LaneChangeStatusWire::Builder::getModelTimestampEofNs() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void AolAxisState::LaneChangeStatusWire::Builder::setModelTimestampEofNs( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t AolAxisState::LaneChangeStatusWire::Reader::getObservedMonoTimeNs() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t AolAxisState::LaneChangeStatusWire::Builder::getObservedMonoTimeNs() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}
inline void AolAxisState::LaneChangeStatusWire::Builder::setObservedMonoTimeNs( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t AolAxisState::LaneChangeStatusWire::Reader::getValidUntilMonoTimeNs() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t AolAxisState::LaneChangeStatusWire::Builder::getValidUntilMonoTimeNs() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}
inline void AolAxisState::LaneChangeStatusWire::Builder::setValidUntilMonoTimeNs( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS, value);
}

inline  ::cereal::AolAxisState::LaneChangeStatusWire::Phase AolAxisState::LaneChangeStatusWire::Reader::getPhase() const {
  return _reader.getDataField< ::cereal::AolAxisState::LaneChangeStatusWire::Phase>(
      ::capnp::bounded<20>() * ::capnp::ELEMENTS);
}

inline  ::cereal::AolAxisState::LaneChangeStatusWire::Phase AolAxisState::LaneChangeStatusWire::Builder::getPhase() {
  return _builder.getDataField< ::cereal::AolAxisState::LaneChangeStatusWire::Phase>(
      ::capnp::bounded<20>() * ::capnp::ELEMENTS);
}
inline void AolAxisState::LaneChangeStatusWire::Builder::setPhase( ::cereal::AolAxisState::LaneChangeStatusWire::Phase value) {
  _builder.setDataField< ::cereal::AolAxisState::LaneChangeStatusWire::Phase>(
      ::capnp::bounded<20>() * ::capnp::ELEMENTS, value);
}

inline  ::cereal::AolAxisState::LaneChangeStatusWire::Direction AolAxisState::LaneChangeStatusWire::Reader::getDirection() const {
  return _reader.getDataField< ::cereal::AolAxisState::LaneChangeStatusWire::Direction>(
      ::capnp::bounded<21>() * ::capnp::ELEMENTS);
}

inline  ::cereal::AolAxisState::LaneChangeStatusWire::Direction AolAxisState::LaneChangeStatusWire::Builder::getDirection() {
  return _builder.getDataField< ::cereal::AolAxisState::LaneChangeStatusWire::Direction>(
      ::capnp::bounded<21>() * ::capnp::ELEMENTS);
}
inline void AolAxisState::LaneChangeStatusWire::Builder::setDirection( ::cereal::AolAxisState::LaneChangeStatusWire::Direction value) {
  _builder.setDataField< ::cereal::AolAxisState::LaneChangeStatusWire::Direction>(
      ::capnp::bounded<21>() * ::capnp::ELEMENTS, value);
}

inline bool AolAxisState::LaneChangeStatusWire::Reader::getAutoConfigured() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<8>() * ::capnp::ELEMENTS);
}

inline bool AolAxisState::LaneChangeStatusWire::Builder::getAutoConfigured() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<8>() * ::capnp::ELEMENTS);
}
inline void AolAxisState::LaneChangeStatusWire::Builder::setAutoConfigured(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<8>() * ::capnp::ELEMENTS, value);
}

inline bool AolAxisState::LaneChangeStatusWire::Reader::getEngaged() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<9>() * ::capnp::ELEMENTS);
}

inline bool AolAxisState::LaneChangeStatusWire::Builder::getEngaged() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<9>() * ::capnp::ELEMENTS);
}
inline void AolAxisState::LaneChangeStatusWire::Builder::setEngaged(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<9>() * ::capnp::ELEMENTS, value);
}

inline bool MapdExtendedOut::Reader::hasDownloadProgress() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool MapdExtendedOut::Builder::hasDownloadProgress() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::cereal::MapdExtendedOut::MapdDownloadProgress::Reader MapdExtendedOut::Reader::getDownloadProgress() const {
  return ::capnp::_::PointerHelpers< ::cereal::MapdExtendedOut::MapdDownloadProgress>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::cereal::MapdExtendedOut::MapdDownloadProgress::Builder MapdExtendedOut::Builder::getDownloadProgress() {
  return ::capnp::_::PointerHelpers< ::cereal::MapdExtendedOut::MapdDownloadProgress>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
#if !CAPNP_LITE
inline  ::cereal::MapdExtendedOut::MapdDownloadProgress::Pipeline MapdExtendedOut::Pipeline::getDownloadProgress() {
  return  ::cereal::MapdExtendedOut::MapdDownloadProgress::Pipeline(_typeless.getPointerField(0));
}
#endif  // !CAPNP_LITE
inline void MapdExtendedOut::Builder::setDownloadProgress( ::cereal::MapdExtendedOut::MapdDownloadProgress::Reader value) {
  ::capnp::_::PointerHelpers< ::cereal::MapdExtendedOut::MapdDownloadProgress>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::cereal::MapdExtendedOut::MapdDownloadProgress::Builder MapdExtendedOut::Builder::initDownloadProgress() {
  return ::capnp::_::PointerHelpers< ::cereal::MapdExtendedOut::MapdDownloadProgress>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void MapdExtendedOut::Builder::adoptDownloadProgress(
    ::capnp::Orphan< ::cereal::MapdExtendedOut::MapdDownloadProgress>&& value) {
  ::capnp::_::PointerHelpers< ::cereal::MapdExtendedOut::MapdDownloadProgress>::adopt(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::cereal::MapdExtendedOut::MapdDownloadProgress> MapdExtendedOut::Builder::disownDownloadProgress() {
  return ::capnp::_::PointerHelpers< ::cereal::MapdExtendedOut::MapdDownloadProgress>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline bool MapdExtendedOut::Reader::hasSettings() const {
  return !_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline bool MapdExtendedOut::Builder::hasSettings() {
  return !_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader MapdExtendedOut::Reader::getSettings() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder MapdExtendedOut::Builder::getSettings() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline void MapdExtendedOut::Builder::setSettings( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder MapdExtendedOut::Builder::initSettings(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), size);
}
inline void MapdExtendedOut::Builder::adoptSettings(
    ::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> MapdExtendedOut::Builder::disownSettings() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}

inline bool MapdExtendedOut::Reader::hasPath() const {
  return !_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline bool MapdExtendedOut::Builder::hasPath() {
  return !_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::List< ::cereal::MapdExtendedOut::MapdPathPoint,  ::capnp::Kind::STRUCT>::Reader MapdExtendedOut::Reader::getPath() const {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::MapdExtendedOut::MapdPathPoint,  ::capnp::Kind::STRUCT>>::get(_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline  ::capnp::List< ::cereal::MapdExtendedOut::MapdPathPoint,  ::capnp::Kind::STRUCT>::Builder MapdExtendedOut::Builder::getPath() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::MapdExtendedOut::MapdPathPoint,  ::capnp::Kind::STRUCT>>::get(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline void MapdExtendedOut::Builder::setPath( ::capnp::List< ::cereal::MapdExtendedOut::MapdPathPoint,  ::capnp::Kind::STRUCT>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::MapdExtendedOut::MapdPathPoint,  ::capnp::Kind::STRUCT>>::set(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), value);
}
inline  ::capnp::List< ::cereal::MapdExtendedOut::MapdPathPoint,  ::capnp::Kind::STRUCT>::Builder MapdExtendedOut::Builder::initPath(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::MapdExtendedOut::MapdPathPoint,  ::capnp::Kind::STRUCT>>::init(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), size);
}
inline void MapdExtendedOut::Builder::adoptPath(
    ::capnp::Orphan< ::capnp::List< ::cereal::MapdExtendedOut::MapdPathPoint,  ::capnp::Kind::STRUCT>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::MapdExtendedOut::MapdPathPoint,  ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List< ::cereal::MapdExtendedOut::MapdPathPoint,  ::capnp::Kind::STRUCT>> MapdExtendedOut::Builder::disownPath() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::MapdExtendedOut::MapdPathPoint,  ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}

inline bool MapdExtendedOut::Reader::hasPosition() const {
  return !_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline bool MapdExtendedOut::Builder::hasPosition() {
  return !_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline  ::cereal::MapdExtendedOut::MapdPosition::Reader MapdExtendedOut::Reader::getPosition() const {
  return ::capnp::_::PointerHelpers< ::cereal::MapdExtendedOut::MapdPosition>::get(_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline  ::cereal::MapdExtendedOut::MapdPosition::Builder MapdExtendedOut::Builder::getPosition() {
  return ::capnp::_::PointerHelpers< ::cereal::MapdExtendedOut::MapdPosition>::get(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
#if !CAPNP_LITE
inline  ::cereal::MapdExtendedOut::MapdPosition::Pipeline MapdExtendedOut::Pipeline::getPosition() {
  return  ::cereal::MapdExtendedOut::MapdPosition::Pipeline(_typeless.getPointerField(3));
}
#endif  // !CAPNP_LITE
inline void MapdExtendedOut::Builder::setPosition( ::cereal::MapdExtendedOut::MapdPosition::Reader value) {
  ::capnp::_::PointerHelpers< ::cereal::MapdExtendedOut::MapdPosition>::set(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), value);
}
inline  ::cereal::MapdExtendedOut::MapdPosition::Builder MapdExtendedOut::Builder::initPosition() {
  return ::capnp::_::PointerHelpers< ::cereal::MapdExtendedOut::MapdPosition>::init(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline void MapdExtendedOut::Builder::adoptPosition(
    ::capnp::Orphan< ::cereal::MapdExtendedOut::MapdPosition>&& value) {
  ::capnp::_::PointerHelpers< ::cereal::MapdExtendedOut::MapdPosition>::adopt(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::cereal::MapdExtendedOut::MapdPosition> MapdExtendedOut::Builder::disownPosition() {
  return ::capnp::_::PointerHelpers< ::cereal::MapdExtendedOut::MapdPosition>::disown(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}

inline float MapdExtendedOut::Reader::getLoopRateAverage() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline float MapdExtendedOut::Builder::getLoopRateAverage() {
  return _builder.getDataField<float>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void MapdExtendedOut::Builder::setLoopRateAverage(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline float MapdExtendedOut::Reader::getLoopRateMin() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline float MapdExtendedOut::Builder::getLoopRateMin() {
  return _builder.getDataField<float>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void MapdExtendedOut::Builder::setLoopRateMin(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline bool MapdExtendedOut::MapdDownloadLocationDetails::Reader::hasLocation() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool MapdExtendedOut::MapdDownloadLocationDetails::Builder::hasLocation() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader MapdExtendedOut::MapdDownloadLocationDetails::Reader::getLocation() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder MapdExtendedOut::MapdDownloadLocationDetails::Builder::getLocation() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void MapdExtendedOut::MapdDownloadLocationDetails::Builder::setLocation( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder MapdExtendedOut::MapdDownloadLocationDetails::Builder::initLocation(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void MapdExtendedOut::MapdDownloadLocationDetails::Builder::adoptLocation(
    ::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> MapdExtendedOut::MapdDownloadLocationDetails::Builder::disownLocation() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

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

inline  ::uint32_t MapdExtendedOut::MapdDownloadLocationDetails::Builder::getTotalFiles() {
  return _builder.getDataField< ::uint32_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void MapdExtendedOut::MapdDownloadLocationDetails::Builder::setTotalFiles( ::uint32_t value) {
  _builder.setDataField< ::uint32_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

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

inline  ::uint32_t MapdExtendedOut::MapdDownloadLocationDetails::Builder::getDownloadedFiles() {
  return _builder.getDataField< ::uint32_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void MapdExtendedOut::MapdDownloadLocationDetails::Builder::setDownloadedFiles( ::uint32_t value) {
  _builder.setDataField< ::uint32_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline bool MapdExtendedOut::MapdDownloadProgress::Reader::getActive() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline bool MapdExtendedOut::MapdDownloadProgress::Builder::getActive() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void MapdExtendedOut::MapdDownloadProgress::Builder::setActive(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool MapdExtendedOut::MapdDownloadProgress::Reader::getCancelled() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline bool MapdExtendedOut::MapdDownloadProgress::Builder::getCancelled() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void MapdExtendedOut::MapdDownloadProgress::Builder::setCancelled(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

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

inline  ::uint32_t MapdExtendedOut::MapdDownloadProgress::Builder::getTotalFiles() {
  return _builder.getDataField< ::uint32_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void MapdExtendedOut::MapdDownloadProgress::Builder::setTotalFiles( ::uint32_t value) {
  _builder.setDataField< ::uint32_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

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

inline  ::uint32_t MapdExtendedOut::MapdDownloadProgress::Builder::getDownloadedFiles() {
  return _builder.getDataField< ::uint32_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void MapdExtendedOut::MapdDownloadProgress::Builder::setDownloadedFiles( ::uint32_t value) {
  _builder.setDataField< ::uint32_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline bool MapdExtendedOut::MapdDownloadProgress::Reader::hasLocations() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool MapdExtendedOut::MapdDownloadProgress::Builder::hasLocations() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>::Reader MapdExtendedOut::MapdDownloadProgress::Reader::getLocations() const {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>::Builder MapdExtendedOut::MapdDownloadProgress::Builder::getLocations() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void MapdExtendedOut::MapdDownloadProgress::Builder::setLocations( ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline void MapdExtendedOut::MapdDownloadProgress::Builder::setLocations(::kj::ArrayPtr<const  ::capnp::Text::Reader> value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>::Builder MapdExtendedOut::MapdDownloadProgress::Builder::initLocations(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void MapdExtendedOut::MapdDownloadProgress::Builder::adoptLocations(
    ::capnp::Orphan< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>::adopt(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>> MapdExtendedOut::MapdDownloadProgress::Builder::disownLocations() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline bool MapdExtendedOut::MapdDownloadProgress::Reader::hasLocationDetails() const {
  return !_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline bool MapdExtendedOut::MapdDownloadProgress::Builder::hasLocationDetails() {
  return !_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::List< ::cereal::MapdExtendedOut::MapdDownloadLocationDetails,  ::capnp::Kind::STRUCT>::Reader MapdExtendedOut::MapdDownloadProgress::Reader::getLocationDetails() const {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::MapdExtendedOut::MapdDownloadLocationDetails,  ::capnp::Kind::STRUCT>>::get(_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline  ::capnp::List< ::cereal::MapdExtendedOut::MapdDownloadLocationDetails,  ::capnp::Kind::STRUCT>::Builder MapdExtendedOut::MapdDownloadProgress::Builder::getLocationDetails() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::MapdExtendedOut::MapdDownloadLocationDetails,  ::capnp::Kind::STRUCT>>::get(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline void MapdExtendedOut::MapdDownloadProgress::Builder::setLocationDetails( ::capnp::List< ::cereal::MapdExtendedOut::MapdDownloadLocationDetails,  ::capnp::Kind::STRUCT>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::MapdExtendedOut::MapdDownloadLocationDetails,  ::capnp::Kind::STRUCT>>::set(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), value);
}
inline  ::capnp::List< ::cereal::MapdExtendedOut::MapdDownloadLocationDetails,  ::capnp::Kind::STRUCT>::Builder MapdExtendedOut::MapdDownloadProgress::Builder::initLocationDetails(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::MapdExtendedOut::MapdDownloadLocationDetails,  ::capnp::Kind::STRUCT>>::init(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), size);
}
inline void MapdExtendedOut::MapdDownloadProgress::Builder::adoptLocationDetails(
    ::capnp::Orphan< ::capnp::List< ::cereal::MapdExtendedOut::MapdDownloadLocationDetails,  ::capnp::Kind::STRUCT>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::MapdExtendedOut::MapdDownloadLocationDetails,  ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List< ::cereal::MapdExtendedOut::MapdDownloadLocationDetails,  ::capnp::Kind::STRUCT>> MapdExtendedOut::MapdDownloadProgress::Builder::disownLocationDetails() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::MapdExtendedOut::MapdDownloadLocationDetails,  ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}

inline double MapdExtendedOut::MapdPathPoint::Reader::getLatitude() const {
  return _reader.getDataField<double>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline double MapdExtendedOut::MapdPathPoint::Builder::getLatitude() {
  return _builder.getDataField<double>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void MapdExtendedOut::MapdPathPoint::Builder::setLatitude(double value) {
  _builder.setDataField<double>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline double MapdExtendedOut::MapdPathPoint::Reader::getLongitude() const {
  return _reader.getDataField<double>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline double MapdExtendedOut::MapdPathPoint::Builder::getLongitude() {
  return _builder.getDataField<double>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void MapdExtendedOut::MapdPathPoint::Builder::setLongitude(double value) {
  _builder.setDataField<double>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

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

inline float MapdExtendedOut::MapdPathPoint::Builder::getCurvature() {
  return _builder.getDataField<float>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}
inline void MapdExtendedOut::MapdPathPoint::Builder::setCurvature(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS, value);
}

inline float MapdExtendedOut::MapdPathPoint::Reader::getTargetVelocity() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}

inline float MapdExtendedOut::MapdPathPoint::Builder::getTargetVelocity() {
  return _builder.getDataField<float>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}
inline void MapdExtendedOut::MapdPathPoint::Builder::setTargetVelocity(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS, value);
}

inline double MapdExtendedOut::MapdPosition::Reader::getLatitude() const {
  return _reader.getDataField<double>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline double MapdExtendedOut::MapdPosition::Builder::getLatitude() {
  return _builder.getDataField<double>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void MapdExtendedOut::MapdPosition::Builder::setLatitude(double value) {
  _builder.setDataField<double>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline double MapdExtendedOut::MapdPosition::Reader::getLongitude() const {
  return _reader.getDataField<double>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline double MapdExtendedOut::MapdPosition::Builder::getLongitude() {
  return _builder.getDataField<double>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void MapdExtendedOut::MapdPosition::Builder::setLongitude(double value) {
  _builder.setDataField<double>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline  ::cereal::MapdIn::MapdInputType MapdIn::Reader::getType() const {
  return _reader.getDataField< ::cereal::MapdIn::MapdInputType>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline  ::cereal::MapdIn::MapdInputType MapdIn::Builder::getType() {
  return _builder.getDataField< ::cereal::MapdIn::MapdInputType>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void MapdIn::Builder::setType( ::cereal::MapdIn::MapdInputType value) {
  _builder.setDataField< ::cereal::MapdIn::MapdInputType>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline float MapdIn::Reader::getFloat() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline float MapdIn::Builder::getFloat() {
  return _builder.getDataField<float>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void MapdIn::Builder::setFloat(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline bool MapdIn::Reader::hasStr() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool MapdIn::Builder::hasStr() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader MapdIn::Reader::getStr() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder MapdIn::Builder::getStr() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void MapdIn::Builder::setStr( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder MapdIn::Builder::initStr(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void MapdIn::Builder::adoptStr(
    ::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> MapdIn::Builder::disownStr() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline bool MapdIn::Reader::getBool() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS);
}

inline bool MapdIn::Builder::getBool() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS);
}
inline void MapdIn::Builder::setBool(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS, value);
}

inline bool MapdIn::Reader::hasJsonPath() const {
  return !_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline bool MapdIn::Builder::hasJsonPath() {
  return !_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader MapdIn::Reader::getJsonPath() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder MapdIn::Builder::getJsonPath() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline void MapdIn::Builder::setJsonPath( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder MapdIn::Builder::initJsonPath(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), size);
}
inline void MapdIn::Builder::adoptJsonPath(
    ::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> MapdIn::Builder::disownJsonPath() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}

inline bool MapdOut::Reader::hasWayName() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool MapdOut::Builder::hasWayName() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader MapdOut::Reader::getWayName() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder MapdOut::Builder::getWayName() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void MapdOut::Builder::setWayName( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder MapdOut::Builder::initWayName(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void MapdOut::Builder::adoptWayName(
    ::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> MapdOut::Builder::disownWayName() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline bool MapdOut::Reader::hasWayRef() const {
  return !_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline bool MapdOut::Builder::hasWayRef() {
  return !_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader MapdOut::Reader::getWayRef() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder MapdOut::Builder::getWayRef() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline void MapdOut::Builder::setWayRef( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder MapdOut::Builder::initWayRef(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), size);
}
inline void MapdOut::Builder::adoptWayRef(
    ::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> MapdOut::Builder::disownWayRef() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}

inline bool MapdOut::Reader::hasRoadName() const {
  return !_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline bool MapdOut::Builder::hasRoadName() {
  return !_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader MapdOut::Reader::getRoadName() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder MapdOut::Builder::getRoadName() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline void MapdOut::Builder::setRoadName( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder MapdOut::Builder::initRoadName(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), size);
}
inline void MapdOut::Builder::adoptRoadName(
    ::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> MapdOut::Builder::disownRoadName() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}

inline float MapdOut::Reader::getSpeedLimit() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline float MapdOut::Builder::getSpeedLimit() {
  return _builder.getDataField<float>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void MapdOut::Builder::setSpeedLimit(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline float MapdOut::Reader::getNextSpeedLimit() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline float MapdOut::Builder::getNextSpeedLimit() {
  return _builder.getDataField<float>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void MapdOut::Builder::setNextSpeedLimit(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline float MapdOut::Reader::getNextSpeedLimitDistance() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline float MapdOut::Builder::getNextSpeedLimitDistance() {
  return _builder.getDataField<float>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void MapdOut::Builder::setNextSpeedLimitDistance(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline bool MapdOut::Reader::hasHazard() const {
  return !_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline bool MapdOut::Builder::hasHazard() {
  return !_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader MapdOut::Reader::getHazard() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder MapdOut::Builder::getHazard() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline void MapdOut::Builder::setHazard( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder MapdOut::Builder::initHazard(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), size);
}
inline void MapdOut::Builder::adoptHazard(
    ::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> MapdOut::Builder::disownHazard() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}

inline bool MapdOut::Reader::hasNextHazard() const {
  return !_reader.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS).isNull();
}
inline bool MapdOut::Builder::hasNextHazard() {
  return !_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader MapdOut::Reader::getNextHazard() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder MapdOut::Builder::getNextHazard() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}
inline void MapdOut::Builder::setNextHazard( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder MapdOut::Builder::initNextHazard(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), size);
}
inline void MapdOut::Builder::adoptNextHazard(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> MapdOut::Builder::disownNextHazard() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}

inline float MapdOut::Reader::getNextHazardDistance() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}

inline float MapdOut::Builder::getNextHazardDistance() {
  return _builder.getDataField<float>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}
inline void MapdOut::Builder::setNextHazardDistance(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS, value);
}

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

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

inline float MapdOut::Reader::getNextAdvisorySpeed() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}

inline float MapdOut::Builder::getNextAdvisorySpeed() {
  return _builder.getDataField<float>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}
inline void MapdOut::Builder::setNextAdvisorySpeed(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS, value);
}

inline float MapdOut::Reader::getNextAdvisorySpeedDistance() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS);
}

inline float MapdOut::Builder::getNextAdvisorySpeedDistance() {
  return _builder.getDataField<float>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS);
}
inline void MapdOut::Builder::setNextAdvisorySpeedDistance(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS, value);
}

inline bool MapdOut::Reader::getOneWay() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<224>() * ::capnp::ELEMENTS);
}

inline bool MapdOut::Builder::getOneWay() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<224>() * ::capnp::ELEMENTS);
}
inline void MapdOut::Builder::setOneWay(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<224>() * ::capnp::ELEMENTS, value);
}

inline  ::uint8_t MapdOut::Reader::getLanes() const {
  return _reader.getDataField< ::uint8_t>(
      ::capnp::bounded<29>() * ::capnp::ELEMENTS);
}

inline  ::uint8_t MapdOut::Builder::getLanes() {
  return _builder.getDataField< ::uint8_t>(
      ::capnp::bounded<29>() * ::capnp::ELEMENTS);
}
inline void MapdOut::Builder::setLanes( ::uint8_t value) {
  _builder.setDataField< ::uint8_t>(
      ::capnp::bounded<29>() * ::capnp::ELEMENTS, value);
}

inline bool MapdOut::Reader::getTileLoaded() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<225>() * ::capnp::ELEMENTS);
}

inline bool MapdOut::Builder::getTileLoaded() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<225>() * ::capnp::ELEMENTS);
}
inline void MapdOut::Builder::setTileLoaded(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<225>() * ::capnp::ELEMENTS, value);
}

inline float MapdOut::Reader::getSpeedLimitSuggestedSpeed() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<8>() * ::capnp::ELEMENTS);
}

inline float MapdOut::Builder::getSpeedLimitSuggestedSpeed() {
  return _builder.getDataField<float>(
      ::capnp::bounded<8>() * ::capnp::ELEMENTS);
}
inline void MapdOut::Builder::setSpeedLimitSuggestedSpeed(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<8>() * ::capnp::ELEMENTS, value);
}

inline float MapdOut::Reader::getSuggestedSpeed() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<9>() * ::capnp::ELEMENTS);
}

inline float MapdOut::Builder::getSuggestedSpeed() {
  return _builder.getDataField<float>(
      ::capnp::bounded<9>() * ::capnp::ELEMENTS);
}
inline void MapdOut::Builder::setSuggestedSpeed(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<9>() * ::capnp::ELEMENTS, value);
}

inline float MapdOut::Reader::getEstimatedRoadWidth() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<10>() * ::capnp::ELEMENTS);
}

inline float MapdOut::Builder::getEstimatedRoadWidth() {
  return _builder.getDataField<float>(
      ::capnp::bounded<10>() * ::capnp::ELEMENTS);
}
inline void MapdOut::Builder::setEstimatedRoadWidth(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<10>() * ::capnp::ELEMENTS, value);
}

inline  ::cereal::MapdOut::RoadContext MapdOut::Reader::getRoadContext() const {
  return _reader.getDataField< ::cereal::MapdOut::RoadContext>(
      ::capnp::bounded<15>() * ::capnp::ELEMENTS);
}

inline  ::cereal::MapdOut::RoadContext MapdOut::Builder::getRoadContext() {
  return _builder.getDataField< ::cereal::MapdOut::RoadContext>(
      ::capnp::bounded<15>() * ::capnp::ELEMENTS);
}
inline void MapdOut::Builder::setRoadContext( ::cereal::MapdOut::RoadContext value) {
  _builder.setDataField< ::cereal::MapdOut::RoadContext>(
      ::capnp::bounded<15>() * ::capnp::ELEMENTS, value);
}

inline float MapdOut::Reader::getDistanceFromWayCenter() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<11>() * ::capnp::ELEMENTS);
}

inline float MapdOut::Builder::getDistanceFromWayCenter() {
  return _builder.getDataField<float>(
      ::capnp::bounded<11>() * ::capnp::ELEMENTS);
}
inline void MapdOut::Builder::setDistanceFromWayCenter(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<11>() * ::capnp::ELEMENTS, value);
}

inline float MapdOut::Reader::getVisionCurveSpeed() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<12>() * ::capnp::ELEMENTS);
}

inline float MapdOut::Builder::getVisionCurveSpeed() {
  return _builder.getDataField<float>(
      ::capnp::bounded<12>() * ::capnp::ELEMENTS);
}
inline void MapdOut::Builder::setVisionCurveSpeed(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<12>() * ::capnp::ELEMENTS, value);
}

inline float MapdOut::Reader::getMapCurveSpeed() const {
  return _reader.getDataField<float>(
      ::capnp::bounded<13>() * ::capnp::ELEMENTS);
}

inline float MapdOut::Builder::getMapCurveSpeed() {
  return _builder.getDataField<float>(
      ::capnp::bounded<13>() * ::capnp::ELEMENTS);
}
inline void MapdOut::Builder::setMapCurveSpeed(float value) {
  _builder.setDataField<float>(
      ::capnp::bounded<13>() * ::capnp::ELEMENTS, value);
}

inline  ::cereal::MapdOut::WaySelectionType MapdOut::Reader::getWaySelectionType() const {
  return _reader.getDataField< ::cereal::MapdOut::WaySelectionType>(
      ::capnp::bounded<28>() * ::capnp::ELEMENTS);
}

inline  ::cereal::MapdOut::WaySelectionType MapdOut::Builder::getWaySelectionType() {
  return _builder.getDataField< ::cereal::MapdOut::WaySelectionType>(
      ::capnp::bounded<28>() * ::capnp::ELEMENTS);
}
inline void MapdOut::Builder::setWaySelectionType( ::cereal::MapdOut::WaySelectionType value) {
  _builder.setDataField< ::cereal::MapdOut::WaySelectionType>(
      ::capnp::bounded<28>() * ::capnp::ELEMENTS, value);
}

inline bool MapdOut::Reader::getSpeedLimitAccepted() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<226>() * ::capnp::ELEMENTS);
}

inline bool MapdOut::Builder::getSpeedLimitAccepted() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<226>() * ::capnp::ELEMENTS);
}
inline void MapdOut::Builder::setSpeedLimitAccepted(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<226>() * ::capnp::ELEMENTS, value);
}

inline  ::cereal::MapdOut::HighwayClass MapdOut::Reader::getHighwayClass() const {
  return _reader.getDataField< ::cereal::MapdOut::HighwayClass>(
      ::capnp::bounded<29>() * ::capnp::ELEMENTS);
}

inline  ::cereal::MapdOut::HighwayClass MapdOut::Builder::getHighwayClass() {
  return _builder.getDataField< ::cereal::MapdOut::HighwayClass>(
      ::capnp::bounded<29>() * ::capnp::ELEMENTS);
}
inline void MapdOut::Builder::setHighwayClass( ::cereal::MapdOut::HighwayClass value) {
  _builder.setDataField< ::cereal::MapdOut::HighwayClass>(
      ::capnp::bounded<29>() * ::capnp::ELEMENTS, value);
}

inline  ::int64_t MapdOut::Reader::getWayId() const {
  return _reader.getDataField< ::int64_t>(
      ::capnp::bounded<8>() * ::capnp::ELEMENTS);
}

inline  ::int64_t MapdOut::Builder::getWayId() {
  return _builder.getDataField< ::int64_t>(
      ::capnp::bounded<8>() * ::capnp::ELEMENTS);
}
inline void MapdOut::Builder::setWayId( ::int64_t value) {
  _builder.setDataField< ::int64_t>(
      ::capnp::bounded<8>() * ::capnp::ELEMENTS, value);
}

inline bool MapdOut::Reader::hasConditionalSpeedLimit() const {
  return !_reader.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS).isNull();
}
inline bool MapdOut::Builder::hasConditionalSpeedLimit() {
  return !_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader MapdOut::Reader::getConditionalSpeedLimit() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder MapdOut::Builder::getConditionalSpeedLimit() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS));
}
inline void MapdOut::Builder::setConditionalSpeedLimit( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder MapdOut::Builder::initConditionalSpeedLimit(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS), size);
}
inline void MapdOut::Builder::adoptConditionalSpeedLimit(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> MapdOut::Builder::disownConditionalSpeedLimit() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS));
}

inline  ::uint16_t MapdOut::Reader::getSampleVersion() const {
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<30>() * ::capnp::ELEMENTS);
}

inline  ::uint16_t MapdOut::Builder::getSampleVersion() {
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<30>() * ::capnp::ELEMENTS);
}
inline void MapdOut::Builder::setSampleVersion( ::uint16_t value) {
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<30>() * ::capnp::ELEMENTS, value);
}

inline  ::cereal::MapdOut::SampleStatus MapdOut::Reader::getRoadStatus() const {
  return _reader.getDataField< ::cereal::MapdOut::SampleStatus>(
      ::capnp::bounded<31>() * ::capnp::ELEMENTS);
}

inline  ::cereal::MapdOut::SampleStatus MapdOut::Builder::getRoadStatus() {
  return _builder.getDataField< ::cereal::MapdOut::SampleStatus>(
      ::capnp::bounded<31>() * ::capnp::ELEMENTS);
}
inline void MapdOut::Builder::setRoadStatus( ::cereal::MapdOut::SampleStatus value) {
  _builder.setDataField< ::cereal::MapdOut::SampleStatus>(
      ::capnp::bounded<31>() * ::capnp::ELEMENTS, value);
}

inline  ::cereal::MapdOut::GpsSource MapdOut::Reader::getGpsSource() const {
  return _reader.getDataField< ::cereal::MapdOut::GpsSource>(
      ::capnp::bounded<36>() * ::capnp::ELEMENTS);
}

inline  ::cereal::MapdOut::GpsSource MapdOut::Builder::getGpsSource() {
  return _builder.getDataField< ::cereal::MapdOut::GpsSource>(
      ::capnp::bounded<36>() * ::capnp::ELEMENTS);
}
inline void MapdOut::Builder::setGpsSource( ::cereal::MapdOut::GpsSource value) {
  _builder.setDataField< ::cereal::MapdOut::GpsSource>(
      ::capnp::bounded<36>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t MapdOut::Reader::getGpsMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<10>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t MapdOut::Builder::getGpsMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<10>() * ::capnp::ELEMENTS);
}
inline void MapdOut::Builder::setGpsMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<10>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t MapdOut::Reader::getComputedMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<11>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t MapdOut::Builder::getComputedMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<11>() * ::capnp::ELEMENTS);
}
inline void MapdOut::Builder::setComputedMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<11>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t MapdOut::Reader::getSourceGeneration() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<12>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t MapdOut::Builder::getSourceGeneration() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<12>() * ::capnp::ELEMENTS);
}
inline void MapdOut::Builder::setSourceGeneration( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<12>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t MapdOut::Reader::getProducerSession() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<13>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t MapdOut::Builder::getProducerSession() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<13>() * ::capnp::ELEMENTS);
}
inline void MapdOut::Builder::setProducerSession( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<13>() * ::capnp::ELEMENTS, value);
}

inline  ::uint16_t LearningControlEvidence::Reader::getVersion() const {
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline  ::uint16_t LearningControlEvidence::Builder::getVersion() {
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void LearningControlEvidence::Builder::setVersion( ::uint16_t value) {
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool LearningControlEvidence::Reader::hasIdentity() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool LearningControlEvidence::Builder::hasIdentity() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader LearningControlEvidence::Reader::getIdentity() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder LearningControlEvidence::Builder::getIdentity() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void LearningControlEvidence::Builder::setIdentity( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder LearningControlEvidence::Builder::initIdentity(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void LearningControlEvidence::Builder::adoptIdentity(
    ::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> LearningControlEvidence::Builder::disownIdentity() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline  ::uint64_t LearningControlEvidence::Reader::getGeneration() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t LearningControlEvidence::Builder::getGeneration() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void LearningControlEvidence::Builder::setGeneration( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t LearningControlEvidence::Reader::getControlMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t LearningControlEvidence::Builder::getControlMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void LearningControlEvidence::Builder::setControlMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t LearningControlEvidence::Reader::getSourceStateMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t LearningControlEvidence::Builder::getSourceStateMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}
inline void LearningControlEvidence::Builder::setSourceStateMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS, value);
}

inline bool LearningControlEvidence::Reader::hasDomain() const {
  return !_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline bool LearningControlEvidence::Builder::hasDomain() {
  return !_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader LearningControlEvidence::Reader::getDomain() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder LearningControlEvidence::Builder::getDomain() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline void LearningControlEvidence::Builder::setDomain( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder LearningControlEvidence::Builder::initDomain(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), size);
}
inline void LearningControlEvidence::Builder::adoptDomain(
    ::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> LearningControlEvidence::Builder::disownDomain() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}

inline bool LearningControlEvidence::Reader::hasStageRevision() const {
  return !_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline bool LearningControlEvidence::Builder::hasStageRevision() {
  return !_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader LearningControlEvidence::Reader::getStageRevision() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder LearningControlEvidence::Builder::getStageRevision() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline void LearningControlEvidence::Builder::setStageRevision( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder LearningControlEvidence::Builder::initStageRevision(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), size);
}
inline void LearningControlEvidence::Builder::adoptStageRevision(
    ::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> LearningControlEvidence::Builder::disownStageRevision() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}

inline bool LearningControlEvidence::Reader::hasResponseRevision() const {
  return !_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline bool LearningControlEvidence::Builder::hasResponseRevision() {
  return !_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader LearningControlEvidence::Reader::getResponseRevision() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder LearningControlEvidence::Builder::getResponseRevision() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline void LearningControlEvidence::Builder::setResponseRevision( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder LearningControlEvidence::Builder::initResponseRevision(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), size);
}
inline void LearningControlEvidence::Builder::adoptResponseRevision(
    ::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> LearningControlEvidence::Builder::disownResponseRevision() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}

inline double LearningControlEvidence::Reader::getRequested() const {
  return _reader.getDataField<double>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}

inline double LearningControlEvidence::Builder::getRequested() {
  return _builder.getDataField<double>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}
inline void LearningControlEvidence::Builder::setRequested(double value) {
  _builder.setDataField<double>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS, value);
}

inline bool LearningControlEvidence::Reader::hasFeatures() const {
  return !_reader.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS).isNull();
}
inline bool LearningControlEvidence::Builder::hasFeatures() {
  return !_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Reader LearningControlEvidence::Reader::getFeatures() const {
  return ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}
inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Builder LearningControlEvidence::Builder::getFeatures() {
  return ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}
inline void LearningControlEvidence::Builder::setFeatures( ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), value);
}
inline void LearningControlEvidence::Builder::setFeatures(::kj::ArrayPtr<const double> value) {
  ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), value);
}
inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Builder LearningControlEvidence::Builder::initFeatures(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), size);
}
inline void LearningControlEvidence::Builder::adoptFeatures(
    ::capnp::Orphan< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>> LearningControlEvidence::Builder::disownFeatures() {
  return ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}

inline double LearningControlEvidence::Reader::getBaselinePrediction() const {
  return _reader.getDataField<double>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}

inline double LearningControlEvidence::Builder::getBaselinePrediction() {
  return _builder.getDataField<double>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}
inline void LearningControlEvidence::Builder::setBaselinePrediction(double value) {
  _builder.setDataField<double>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS, value);
}

inline bool LearningControlEvidence::Reader::getEnabled() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS);
}

inline bool LearningControlEvidence::Builder::getEnabled() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS);
}
inline void LearningControlEvidence::Builder::setEnabled(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS, value);
}

inline bool LearningControlEvidence::Reader::getManual() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<17>() * ::capnp::ELEMENTS);
}

inline bool LearningControlEvidence::Builder::getManual() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<17>() * ::capnp::ELEMENTS);
}
inline void LearningControlEvidence::Builder::setManual(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<17>() * ::capnp::ELEMENTS, value);
}

inline bool LearningControlEvidence::Reader::getActive() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<18>() * ::capnp::ELEMENTS);
}

inline bool LearningControlEvidence::Builder::getActive() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<18>() * ::capnp::ELEMENTS);
}
inline void LearningControlEvidence::Builder::setActive(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<18>() * ::capnp::ELEMENTS, value);
}

inline bool LearningControlEvidence::Reader::getValid() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<19>() * ::capnp::ELEMENTS);
}

inline bool LearningControlEvidence::Builder::getValid() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<19>() * ::capnp::ELEMENTS);
}
inline void LearningControlEvidence::Builder::setValid(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<19>() * ::capnp::ELEMENTS, value);
}

inline bool LearningControlEvidence::Reader::getOverride() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<20>() * ::capnp::ELEMENTS);
}

inline bool LearningControlEvidence::Builder::getOverride() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<20>() * ::capnp::ELEMENTS);
}
inline void LearningControlEvidence::Builder::setOverride(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<20>() * ::capnp::ELEMENTS, value);
}

inline bool LearningControlEvidence::Reader::getFault() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<21>() * ::capnp::ELEMENTS);
}

inline bool LearningControlEvidence::Builder::getFault() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<21>() * ::capnp::ELEMENTS);
}
inline void LearningControlEvidence::Builder::setFault(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<21>() * ::capnp::ELEMENTS, value);
}

inline bool LearningControlEvidence::Reader::getSaturated() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<22>() * ::capnp::ELEMENTS);
}

inline bool LearningControlEvidence::Builder::getSaturated() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<22>() * ::capnp::ELEMENTS);
}
inline void LearningControlEvidence::Builder::setSaturated(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<22>() * ::capnp::ELEMENTS, value);
}

inline bool LearningControlEvidence::Reader::getLimited() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<23>() * ::capnp::ELEMENTS);
}

inline bool LearningControlEvidence::Builder::getLimited() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<23>() * ::capnp::ELEMENTS);
}
inline void LearningControlEvidence::Builder::setLimited(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<23>() * ::capnp::ELEMENTS, value);
}

inline bool LearningControlEvidence::Reader::getModelWobble() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<24>() * ::capnp::ELEMENTS);
}

inline bool LearningControlEvidence::Builder::getModelWobble() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<24>() * ::capnp::ELEMENTS);
}
inline void LearningControlEvidence::Builder::setModelWobble(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<24>() * ::capnp::ELEMENTS, value);
}

inline bool LearningControlEvidence::Reader::getControllerChatter() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<25>() * ::capnp::ELEMENTS);
}

inline bool LearningControlEvidence::Builder::getControllerChatter() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<25>() * ::capnp::ELEMENTS);
}
inline void LearningControlEvidence::Builder::setControllerChatter(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<25>() * ::capnp::ELEMENTS, value);
}

inline bool LearningControlEvidence::Reader::hasStageSchemaRevision() const {
  return !_reader.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS).isNull();
}
inline bool LearningControlEvidence::Builder::hasStageSchemaRevision() {
  return !_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader LearningControlEvidence::Reader::getStageSchemaRevision() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder LearningControlEvidence::Builder::getStageSchemaRevision() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS));
}
inline void LearningControlEvidence::Builder::setStageSchemaRevision( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder LearningControlEvidence::Builder::initStageSchemaRevision(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS), size);
}
inline void LearningControlEvidence::Builder::adoptStageSchemaRevision(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> LearningControlEvidence::Builder::disownStageSchemaRevision() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS));
}

inline bool LearningControlEvidence::Reader::hasStageValues() const {
  return !_reader.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS).isNull();
}
inline bool LearningControlEvidence::Builder::hasStageValues() {
  return !_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>::Reader LearningControlEvidence::Reader::getStageValues() const {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>>::get(_reader.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS));
}
inline  ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>::Builder LearningControlEvidence::Builder::getStageValues() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>>::get(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS));
}
inline void LearningControlEvidence::Builder::setStageValues( ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>>::set(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS), value);
}
inline  ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>::Builder LearningControlEvidence::Builder::initStageValues(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>>::init(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS), size);
}
inline void LearningControlEvidence::Builder::adoptStageValues(
    ::capnp::Orphan< ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>> LearningControlEvidence::Builder::disownStageValues() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS));
}

inline bool LearningControlEvidence::Reader::hasAppliedCoordinates() const {
  return !_reader.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS).isNull();
}
inline bool LearningControlEvidence::Builder::hasAppliedCoordinates() {
  return !_builder.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Reader LearningControlEvidence::Reader::getAppliedCoordinates() const {
  return ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS));
}
inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Builder LearningControlEvidence::Builder::getAppliedCoordinates() {
  return ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS));
}
inline void LearningControlEvidence::Builder::setAppliedCoordinates( ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS), value);
}
inline void LearningControlEvidence::Builder::setAppliedCoordinates(::kj::ArrayPtr<const double> value) {
  ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS), value);
}
inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Builder LearningControlEvidence::Builder::initAppliedCoordinates(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS), size);
}
inline void LearningControlEvidence::Builder::adoptAppliedCoordinates(
    ::capnp::Orphan< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>> LearningControlEvidence::Builder::disownAppliedCoordinates() {
  return ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS));
}

inline bool LearningControlEvidence::Reader::hasSourceEpoch() const {
  return !_reader.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS).isNull();
}
inline bool LearningControlEvidence::Builder::hasSourceEpoch() {
  return !_builder.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader LearningControlEvidence::Reader::getSourceEpoch() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder LearningControlEvidence::Builder::getSourceEpoch() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS));
}
inline void LearningControlEvidence::Builder::setSourceEpoch( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder LearningControlEvidence::Builder::initSourceEpoch(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS), size);
}
inline void LearningControlEvidence::Builder::adoptSourceEpoch(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> LearningControlEvidence::Builder::disownSourceEpoch() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS));
}

inline  ::uint64_t LearningControlEvidence::Reader::getSourceReceiptMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t LearningControlEvidence::Builder::getSourceReceiptMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS);
}
inline void LearningControlEvidence::Builder::setSourceReceiptMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS, value);
}

inline bool LearningControlEvidence::Reader::hasControllerMode() const {
  return !_reader.getPointerField(
      ::capnp::bounded<9>() * ::capnp::POINTERS).isNull();
}
inline bool LearningControlEvidence::Builder::hasControllerMode() {
  return !_builder.getPointerField(
      ::capnp::bounded<9>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader LearningControlEvidence::Reader::getControllerMode() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<9>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder LearningControlEvidence::Builder::getControllerMode() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<9>() * ::capnp::POINTERS));
}
inline void LearningControlEvidence::Builder::setControllerMode( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<9>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder LearningControlEvidence::Builder::initControllerMode(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<9>() * ::capnp::POINTERS), size);
}
inline void LearningControlEvidence::Builder::adoptControllerMode(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<9>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> LearningControlEvidence::Builder::disownControllerMode() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<9>() * ::capnp::POINTERS));
}

inline bool LearningControlEvidence::Reader::hasPolicy() const {
  return !_reader.getPointerField(
      ::capnp::bounded<10>() * ::capnp::POINTERS).isNull();
}
inline bool LearningControlEvidence::Builder::hasPolicy() {
  return !_builder.getPointerField(
      ::capnp::bounded<10>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader LearningControlEvidence::Reader::getPolicy() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<10>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder LearningControlEvidence::Builder::getPolicy() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<10>() * ::capnp::POINTERS));
}
inline void LearningControlEvidence::Builder::setPolicy( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<10>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder LearningControlEvidence::Builder::initPolicy(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<10>() * ::capnp::POINTERS), size);
}
inline void LearningControlEvidence::Builder::adoptPolicy(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<10>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> LearningControlEvidence::Builder::disownPolicy() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<10>() * ::capnp::POINTERS));
}

inline bool LearningControlEvidence::Reader::hasBaselineRevision() const {
  return !_reader.getPointerField(
      ::capnp::bounded<11>() * ::capnp::POINTERS).isNull();
}
inline bool LearningControlEvidence::Builder::hasBaselineRevision() {
  return !_builder.getPointerField(
      ::capnp::bounded<11>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader LearningControlEvidence::Reader::getBaselineRevision() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<11>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder LearningControlEvidence::Builder::getBaselineRevision() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<11>() * ::capnp::POINTERS));
}
inline void LearningControlEvidence::Builder::setBaselineRevision( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<11>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder LearningControlEvidence::Builder::initBaselineRevision(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<11>() * ::capnp::POINTERS), size);
}
inline void LearningControlEvidence::Builder::adoptBaselineRevision(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<11>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> LearningControlEvidence::Builder::disownBaselineRevision() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<11>() * ::capnp::POINTERS));
}

inline bool LearningControlEvidence::Reader::hasBaselineValues() const {
  return !_reader.getPointerField(
      ::capnp::bounded<12>() * ::capnp::POINTERS).isNull();
}
inline bool LearningControlEvidence::Builder::hasBaselineValues() {
  return !_builder.getPointerField(
      ::capnp::bounded<12>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Reader LearningControlEvidence::Reader::getBaselineValues() const {
  return ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField(
      ::capnp::bounded<12>() * ::capnp::POINTERS));
}
inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Builder LearningControlEvidence::Builder::getBaselineValues() {
  return ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField(
      ::capnp::bounded<12>() * ::capnp::POINTERS));
}
inline void LearningControlEvidence::Builder::setBaselineValues( ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField(
      ::capnp::bounded<12>() * ::capnp::POINTERS), value);
}
inline void LearningControlEvidence::Builder::setBaselineValues(::kj::ArrayPtr<const double> value) {
  ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField(
      ::capnp::bounded<12>() * ::capnp::POINTERS), value);
}
inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Builder LearningControlEvidence::Builder::initBaselineValues(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField(
      ::capnp::bounded<12>() * ::capnp::POINTERS), size);
}
inline void LearningControlEvidence::Builder::adoptBaselineValues(
    ::capnp::Orphan< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField(
      ::capnp::bounded<12>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>> LearningControlEvidence::Builder::disownBaselineValues() {
  return ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField(
      ::capnp::bounded<12>() * ::capnp::POINTERS));
}

inline bool LearningControlEvidence::Reader::hasControllerRevision() const {
  return !_reader.getPointerField(
      ::capnp::bounded<13>() * ::capnp::POINTERS).isNull();
}
inline bool LearningControlEvidence::Builder::hasControllerRevision() {
  return !_builder.getPointerField(
      ::capnp::bounded<13>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader LearningControlEvidence::Reader::getControllerRevision() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<13>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder LearningControlEvidence::Builder::getControllerRevision() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<13>() * ::capnp::POINTERS));
}
inline void LearningControlEvidence::Builder::setControllerRevision( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<13>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder LearningControlEvidence::Builder::initControllerRevision(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<13>() * ::capnp::POINTERS), size);
}
inline void LearningControlEvidence::Builder::adoptControllerRevision(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<13>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> LearningControlEvidence::Builder::disownControllerRevision() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<13>() * ::capnp::POINTERS));
}

inline bool LearningControlEvidence::Reader::hasReplaySnapshot() const {
  return !_reader.getPointerField(
      ::capnp::bounded<14>() * ::capnp::POINTERS).isNull();
}
inline bool LearningControlEvidence::Builder::hasReplaySnapshot() {
  return !_builder.getPointerField(
      ::capnp::bounded<14>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>::Reader LearningControlEvidence::Reader::getReplaySnapshot() const {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>>::get(_reader.getPointerField(
      ::capnp::bounded<14>() * ::capnp::POINTERS));
}
inline  ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>::Builder LearningControlEvidence::Builder::getReplaySnapshot() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>>::get(_builder.getPointerField(
      ::capnp::bounded<14>() * ::capnp::POINTERS));
}
inline void LearningControlEvidence::Builder::setReplaySnapshot( ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>>::set(_builder.getPointerField(
      ::capnp::bounded<14>() * ::capnp::POINTERS), value);
}
inline  ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>::Builder LearningControlEvidence::Builder::initReplaySnapshot(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>>::init(_builder.getPointerField(
      ::capnp::bounded<14>() * ::capnp::POINTERS), size);
}
inline void LearningControlEvidence::Builder::adoptReplaySnapshot(
    ::capnp::Orphan< ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField(
      ::capnp::bounded<14>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>> LearningControlEvidence::Builder::disownReplaySnapshot() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField(
      ::capnp::bounded<14>() * ::capnp::POINTERS));
}

inline bool LearningControlEvidence::Reader::hasReplayInputs() const {
  return !_reader.getPointerField(
      ::capnp::bounded<15>() * ::capnp::POINTERS).isNull();
}
inline bool LearningControlEvidence::Builder::hasReplayInputs() {
  return !_builder.getPointerField(
      ::capnp::bounded<15>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>::Reader LearningControlEvidence::Reader::getReplayInputs() const {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>>::get(_reader.getPointerField(
      ::capnp::bounded<15>() * ::capnp::POINTERS));
}
inline  ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>::Builder LearningControlEvidence::Builder::getReplayInputs() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>>::get(_builder.getPointerField(
      ::capnp::bounded<15>() * ::capnp::POINTERS));
}
inline void LearningControlEvidence::Builder::setReplayInputs( ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>>::set(_builder.getPointerField(
      ::capnp::bounded<15>() * ::capnp::POINTERS), value);
}
inline  ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>::Builder LearningControlEvidence::Builder::initReplayInputs(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>>::init(_builder.getPointerField(
      ::capnp::bounded<15>() * ::capnp::POINTERS), size);
}
inline void LearningControlEvidence::Builder::adoptReplayInputs(
    ::capnp::Orphan< ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField(
      ::capnp::bounded<15>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>> LearningControlEvidence::Builder::disownReplayInputs() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField(
      ::capnp::bounded<15>() * ::capnp::POINTERS));
}

inline  ::uint64_t LearningControlEvidence::Reader::getSnapshotSequence() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<7>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t LearningControlEvidence::Builder::getSnapshotSequence() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<7>() * ::capnp::ELEMENTS);
}
inline void LearningControlEvidence::Builder::setSnapshotSequence( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<7>() * ::capnp::ELEMENTS, value);
}

inline bool LearningControlEvidence::Reader::getTurnAssist() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<26>() * ::capnp::ELEMENTS);
}

inline bool LearningControlEvidence::Builder::getTurnAssist() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<26>() * ::capnp::ELEMENTS);
}
inline void LearningControlEvidence::Builder::setTurnAssist(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<26>() * ::capnp::ELEMENTS, value);
}

inline bool LearningControlEvidence::Reader::hasAppliedParameterNames() const {
  return !_reader.getPointerField(
      ::capnp::bounded<16>() * ::capnp::POINTERS).isNull();
}
inline bool LearningControlEvidence::Builder::hasAppliedParameterNames() {
  return !_builder.getPointerField(
      ::capnp::bounded<16>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>::Reader LearningControlEvidence::Reader::getAppliedParameterNames() const {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>::get(_reader.getPointerField(
      ::capnp::bounded<16>() * ::capnp::POINTERS));
}
inline  ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>::Builder LearningControlEvidence::Builder::getAppliedParameterNames() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>::get(_builder.getPointerField(
      ::capnp::bounded<16>() * ::capnp::POINTERS));
}
inline void LearningControlEvidence::Builder::setAppliedParameterNames( ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>::set(_builder.getPointerField(
      ::capnp::bounded<16>() * ::capnp::POINTERS), value);
}
inline void LearningControlEvidence::Builder::setAppliedParameterNames(::kj::ArrayPtr<const  ::capnp::Text::Reader> value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>::set(_builder.getPointerField(
      ::capnp::bounded<16>() * ::capnp::POINTERS), value);
}
inline  ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>::Builder LearningControlEvidence::Builder::initAppliedParameterNames(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>::init(_builder.getPointerField(
      ::capnp::bounded<16>() * ::capnp::POINTERS), size);
}
inline void LearningControlEvidence::Builder::adoptAppliedParameterNames(
    ::capnp::Orphan< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>::adopt(_builder.getPointerField(
      ::capnp::bounded<16>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>> LearningControlEvidence::Builder::disownAppliedParameterNames() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>::disown(_builder.getPointerField(
      ::capnp::bounded<16>() * ::capnp::POINTERS));
}

inline bool LearningControlEvidence::Reader::getNativeRequired() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<27>() * ::capnp::ELEMENTS);
}

inline bool LearningControlEvidence::Builder::getNativeRequired() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<27>() * ::capnp::ELEMENTS);
}
inline void LearningControlEvidence::Builder::setNativeRequired(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<27>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t LearningControlEvidence::Reader::getNativeObservedMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<8>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t LearningControlEvidence::Builder::getNativeObservedMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<8>() * ::capnp::ELEMENTS);
}
inline void LearningControlEvidence::Builder::setNativeObservedMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<8>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t LearningControlEvidence::Reader::getNativeValidUntilMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<9>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t LearningControlEvidence::Builder::getNativeValidUntilMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<9>() * ::capnp::ELEMENTS);
}
inline void LearningControlEvidence::Builder::setNativeValidUntilMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<9>() * ::capnp::ELEMENTS, value);
}

inline bool LearningControlEvidence::Reader::getNativeAllowed() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<28>() * ::capnp::ELEMENTS);
}

inline bool LearningControlEvidence::Builder::getNativeAllowed() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<28>() * ::capnp::ELEMENTS);
}
inline void LearningControlEvidence::Builder::setNativeAllowed(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<28>() * ::capnp::ELEMENTS, value);
}

inline bool LearningControlEvidence::Reader::hasNativeIdentity() const {
  return !_reader.getPointerField(
      ::capnp::bounded<17>() * ::capnp::POINTERS).isNull();
}
inline bool LearningControlEvidence::Builder::hasNativeIdentity() {
  return !_builder.getPointerField(
      ::capnp::bounded<17>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader LearningControlEvidence::Reader::getNativeIdentity() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<17>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder LearningControlEvidence::Builder::getNativeIdentity() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<17>() * ::capnp::POINTERS));
}
inline void LearningControlEvidence::Builder::setNativeIdentity( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<17>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder LearningControlEvidence::Builder::initNativeIdentity(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<17>() * ::capnp::POINTERS), size);
}
inline void LearningControlEvidence::Builder::adoptNativeIdentity(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<17>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> LearningControlEvidence::Builder::disownNativeIdentity() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<17>() * ::capnp::POINTERS));
}

inline  ::uint64_t LearningControlEvidence::Reader::getAppliedProfileSequence() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<10>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t LearningControlEvidence::Builder::getAppliedProfileSequence() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<10>() * ::capnp::ELEMENTS);
}
inline void LearningControlEvidence::Builder::setAppliedProfileSequence( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<10>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t LearningControlEvidence::Reader::getAppliedProfileObservedMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<11>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t LearningControlEvidence::Builder::getAppliedProfileObservedMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<11>() * ::capnp::ELEMENTS);
}
inline void LearningControlEvidence::Builder::setAppliedProfileObservedMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<11>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t LearningControlEvidence::Reader::getAppliedProfileValidUntilMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<12>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t LearningControlEvidence::Builder::getAppliedProfileValidUntilMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<12>() * ::capnp::ELEMENTS);
}
inline void LearningControlEvidence::Builder::setAppliedProfileValidUntilMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<12>() * ::capnp::ELEMENTS, value);
}

inline bool LearningControlEvidence::Reader::hasEffectTrace() const {
  return !_reader.getPointerField(
      ::capnp::bounded<18>() * ::capnp::POINTERS).isNull();
}
inline bool LearningControlEvidence::Builder::hasEffectTrace() {
  return !_builder.getPointerField(
      ::capnp::bounded<18>() * ::capnp::POINTERS).isNull();
}
inline  ::cereal::LearningControlEvidence::FullEffectTrace::Reader LearningControlEvidence::Reader::getEffectTrace() const {
  return ::capnp::_::PointerHelpers< ::cereal::LearningControlEvidence::FullEffectTrace>::get(_reader.getPointerField(
      ::capnp::bounded<18>() * ::capnp::POINTERS));
}
inline  ::cereal::LearningControlEvidence::FullEffectTrace::Builder LearningControlEvidence::Builder::getEffectTrace() {
  return ::capnp::_::PointerHelpers< ::cereal::LearningControlEvidence::FullEffectTrace>::get(_builder.getPointerField(
      ::capnp::bounded<18>() * ::capnp::POINTERS));
}
#if !CAPNP_LITE
inline  ::cereal::LearningControlEvidence::FullEffectTrace::Pipeline LearningControlEvidence::Pipeline::getEffectTrace() {
  return  ::cereal::LearningControlEvidence::FullEffectTrace::Pipeline(_typeless.getPointerField(18));
}
#endif  // !CAPNP_LITE
inline void LearningControlEvidence::Builder::setEffectTrace( ::cereal::LearningControlEvidence::FullEffectTrace::Reader value) {
  ::capnp::_::PointerHelpers< ::cereal::LearningControlEvidence::FullEffectTrace>::set(_builder.getPointerField(
      ::capnp::bounded<18>() * ::capnp::POINTERS), value);
}
inline  ::cereal::LearningControlEvidence::FullEffectTrace::Builder LearningControlEvidence::Builder::initEffectTrace() {
  return ::capnp::_::PointerHelpers< ::cereal::LearningControlEvidence::FullEffectTrace>::init(_builder.getPointerField(
      ::capnp::bounded<18>() * ::capnp::POINTERS));
}
inline void LearningControlEvidence::Builder::adoptEffectTrace(
    ::capnp::Orphan< ::cereal::LearningControlEvidence::FullEffectTrace>&& value) {
  ::capnp::_::PointerHelpers< ::cereal::LearningControlEvidence::FullEffectTrace>::adopt(_builder.getPointerField(
      ::capnp::bounded<18>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::cereal::LearningControlEvidence::FullEffectTrace> LearningControlEvidence::Builder::disownEffectTrace() {
  return ::capnp::_::PointerHelpers< ::cereal::LearningControlEvidence::FullEffectTrace>::disown(_builder.getPointerField(
      ::capnp::bounded<18>() * ::capnp::POINTERS));
}

inline  ::uint64_t LearningControlEvidence::Reader::getEffectPrepareMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<13>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t LearningControlEvidence::Builder::getEffectPrepareMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<13>() * ::capnp::ELEMENTS);
}
inline void LearningControlEvidence::Builder::setEffectPrepareMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<13>() * ::capnp::ELEMENTS, value);
}

inline bool LearningControlEvidence::Reader::hasVehicleModelAnchor() const {
  return !_reader.getPointerField(
      ::capnp::bounded<19>() * ::capnp::POINTERS).isNull();
}
inline bool LearningControlEvidence::Builder::hasVehicleModelAnchor() {
  return !_builder.getPointerField(
      ::capnp::bounded<19>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Reader LearningControlEvidence::Reader::getVehicleModelAnchor() const {
  return ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField(
      ::capnp::bounded<19>() * ::capnp::POINTERS));
}
inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Builder LearningControlEvidence::Builder::getVehicleModelAnchor() {
  return ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField(
      ::capnp::bounded<19>() * ::capnp::POINTERS));
}
inline void LearningControlEvidence::Builder::setVehicleModelAnchor( ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField(
      ::capnp::bounded<19>() * ::capnp::POINTERS), value);
}
inline void LearningControlEvidence::Builder::setVehicleModelAnchor(::kj::ArrayPtr<const double> value) {
  ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField(
      ::capnp::bounded<19>() * ::capnp::POINTERS), value);
}
inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Builder LearningControlEvidence::Builder::initVehicleModelAnchor(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField(
      ::capnp::bounded<19>() * ::capnp::POINTERS), size);
}
inline void LearningControlEvidence::Builder::adoptVehicleModelAnchor(
    ::capnp::Orphan< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField(
      ::capnp::bounded<19>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>> LearningControlEvidence::Builder::disownVehicleModelAnchor() {
  return ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField(
      ::capnp::bounded<19>() * ::capnp::POINTERS));
}

inline bool LearningControlEvidence::Reader::hasLiveAppliedCoordinates() const {
  return !_reader.getPointerField(
      ::capnp::bounded<20>() * ::capnp::POINTERS).isNull();
}
inline bool LearningControlEvidence::Builder::hasLiveAppliedCoordinates() {
  return !_builder.getPointerField(
      ::capnp::bounded<20>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Reader LearningControlEvidence::Reader::getLiveAppliedCoordinates() const {
  return ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField(
      ::capnp::bounded<20>() * ::capnp::POINTERS));
}
inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Builder LearningControlEvidence::Builder::getLiveAppliedCoordinates() {
  return ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField(
      ::capnp::bounded<20>() * ::capnp::POINTERS));
}
inline void LearningControlEvidence::Builder::setLiveAppliedCoordinates( ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField(
      ::capnp::bounded<20>() * ::capnp::POINTERS), value);
}
inline void LearningControlEvidence::Builder::setLiveAppliedCoordinates(::kj::ArrayPtr<const double> value) {
  ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField(
      ::capnp::bounded<20>() * ::capnp::POINTERS), value);
}
inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Builder LearningControlEvidence::Builder::initLiveAppliedCoordinates(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField(
      ::capnp::bounded<20>() * ::capnp::POINTERS), size);
}
inline void LearningControlEvidence::Builder::adoptLiveAppliedCoordinates(
    ::capnp::Orphan< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField(
      ::capnp::bounded<20>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>> LearningControlEvidence::Builder::disownLiveAppliedCoordinates() {
  return ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField(
      ::capnp::bounded<20>() * ::capnp::POINTERS));
}

inline  ::uint16_t LearningControlEvidence::FullEffectTrace::Reader::getVersion() const {
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline  ::uint16_t LearningControlEvidence::FullEffectTrace::Builder::getVersion() {
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void LearningControlEvidence::FullEffectTrace::Builder::setVersion( ::uint16_t value) {
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool LearningControlEvidence::FullEffectTrace::Reader::hasEnvelope() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool LearningControlEvidence::FullEffectTrace::Builder::hasEnvelope() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope::Reader LearningControlEvidence::FullEffectTrace::Reader::getEnvelope() const {
  return ::capnp::_::PointerHelpers< ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder LearningControlEvidence::FullEffectTrace::Builder::getEnvelope() {
  return ::capnp::_::PointerHelpers< ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
#if !CAPNP_LITE
inline  ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope::Pipeline LearningControlEvidence::FullEffectTrace::Pipeline::getEnvelope() {
  return  ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope::Pipeline(_typeless.getPointerField(0));
}
#endif  // !CAPNP_LITE
inline void LearningControlEvidence::FullEffectTrace::Builder::setEnvelope( ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope::Reader value) {
  ::capnp::_::PointerHelpers< ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder LearningControlEvidence::FullEffectTrace::Builder::initEnvelope() {
  return ::capnp::_::PointerHelpers< ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void LearningControlEvidence::FullEffectTrace::Builder::adoptEnvelope(
    ::capnp::Orphan< ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope>&& value) {
  ::capnp::_::PointerHelpers< ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope>::adopt(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope> LearningControlEvidence::FullEffectTrace::Builder::disownEnvelope() {
  return ::capnp::_::PointerHelpers< ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline  ::uint64_t LearningControlEvidence::FullEffectTrace::Reader::getControlMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t LearningControlEvidence::FullEffectTrace::Builder::getControlMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void LearningControlEvidence::FullEffectTrace::Builder::setControlMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t LearningControlEvidence::FullEffectTrace::Reader::getPreviousMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t LearningControlEvidence::FullEffectTrace::Builder::getPreviousMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void LearningControlEvidence::FullEffectTrace::Builder::setPreviousMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline bool LearningControlEvidence::FullEffectTrace::Reader::getQualified() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS);
}

inline bool LearningControlEvidence::FullEffectTrace::Builder::getQualified() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS);
}
inline void LearningControlEvidence::FullEffectTrace::Builder::setQualified(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS, value);
}

inline bool LearningControlEvidence::FullEffectTrace::Reader::hasBefore() const {
  return !_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline bool LearningControlEvidence::FullEffectTrace::Builder::hasBefore() {
  return !_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>::Reader LearningControlEvidence::FullEffectTrace::Reader::getBefore() const {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>>::get(_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline  ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>::Builder LearningControlEvidence::FullEffectTrace::Builder::getBefore() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>>::get(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline void LearningControlEvidence::FullEffectTrace::Builder::setBefore( ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>>::set(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), value);
}
inline  ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>::Builder LearningControlEvidence::FullEffectTrace::Builder::initBefore(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>>::init(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), size);
}
inline void LearningControlEvidence::FullEffectTrace::Builder::adoptBefore(
    ::capnp::Orphan< ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>> LearningControlEvidence::FullEffectTrace::Builder::disownBefore() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}

inline bool LearningControlEvidence::FullEffectTrace::Reader::hasTarget() const {
  return !_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline bool LearningControlEvidence::FullEffectTrace::Builder::hasTarget() {
  return !_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>::Reader LearningControlEvidence::FullEffectTrace::Reader::getTarget() const {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>>::get(_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline  ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>::Builder LearningControlEvidence::FullEffectTrace::Builder::getTarget() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>>::get(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline void LearningControlEvidence::FullEffectTrace::Builder::setTarget( ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>>::set(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), value);
}
inline  ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>::Builder LearningControlEvidence::FullEffectTrace::Builder::initTarget(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>>::init(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), size);
}
inline void LearningControlEvidence::FullEffectTrace::Builder::adoptTarget(
    ::capnp::Orphan< ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>> LearningControlEvidence::FullEffectTrace::Builder::disownTarget() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}

inline bool LearningControlEvidence::FullEffectTrace::Reader::hasApplied() const {
  return !_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline bool LearningControlEvidence::FullEffectTrace::Builder::hasApplied() {
  return !_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>::Reader LearningControlEvidence::FullEffectTrace::Reader::getApplied() const {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>>::get(_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline  ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>::Builder LearningControlEvidence::FullEffectTrace::Builder::getApplied() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>>::get(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline void LearningControlEvidence::FullEffectTrace::Builder::setApplied( ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>>::set(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), value);
}
inline  ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>::Builder LearningControlEvidence::FullEffectTrace::Builder::initApplied(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>>::init(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), size);
}
inline void LearningControlEvidence::FullEffectTrace::Builder::adoptApplied(
    ::capnp::Orphan< ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>> LearningControlEvidence::FullEffectTrace::Builder::disownApplied() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}

inline bool LearningControlEvidence::FullEffectTrace::Reader::hasAppliedFullProfileSha256() const {
  return !_reader.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS).isNull();
}
inline bool LearningControlEvidence::FullEffectTrace::Builder::hasAppliedFullProfileSha256() {
  return !_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader LearningControlEvidence::FullEffectTrace::Reader::getAppliedFullProfileSha256() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder LearningControlEvidence::FullEffectTrace::Builder::getAppliedFullProfileSha256() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}
inline void LearningControlEvidence::FullEffectTrace::Builder::setAppliedFullProfileSha256( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder LearningControlEvidence::FullEffectTrace::Builder::initAppliedFullProfileSha256(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), size);
}
inline void LearningControlEvidence::FullEffectTrace::Builder::adoptAppliedFullProfileSha256(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> LearningControlEvidence::FullEffectTrace::Builder::disownAppliedFullProfileSha256() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}

inline  ::cereal::LearningControlEvidence::NamedValue::Which LearningControlEvidence::NamedValue::Reader::which() const {
  return _reader.getDataField<Which>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}
inline  ::cereal::LearningControlEvidence::NamedValue::Which LearningControlEvidence::NamedValue::Builder::which() {
  return _builder.getDataField<Which>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}

inline bool LearningControlEvidence::NamedValue::Reader::hasName() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool LearningControlEvidence::NamedValue::Builder::hasName() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader LearningControlEvidence::NamedValue::Reader::getName() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder LearningControlEvidence::NamedValue::Builder::getName() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void LearningControlEvidence::NamedValue::Builder::setName( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder LearningControlEvidence::NamedValue::Builder::initName(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void LearningControlEvidence::NamedValue::Builder::adoptName(
    ::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> LearningControlEvidence::NamedValue::Builder::disownName() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline bool LearningControlEvidence::NamedValue::Reader::isNumber() const {
  return which() == LearningControlEvidence::NamedValue::NUMBER;
}
inline bool LearningControlEvidence::NamedValue::Builder::isNumber() {
  return which() == LearningControlEvidence::NamedValue::NUMBER;
}
inline double LearningControlEvidence::NamedValue::Reader::getNumber() const {
  KJ_IREQUIRE((which() == LearningControlEvidence::NamedValue::NUMBER),
              "Must check which() before get()ing a union member.");
  return _reader.getDataField<double>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline double LearningControlEvidence::NamedValue::Builder::getNumber() {
  KJ_IREQUIRE((which() == LearningControlEvidence::NamedValue::NUMBER),
              "Must check which() before get()ing a union member.");
  return _builder.getDataField<double>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void LearningControlEvidence::NamedValue::Builder::setNumber(double value) {
  _builder.setDataField<LearningControlEvidence::NamedValue::Which>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS, LearningControlEvidence::NamedValue::NUMBER);
  _builder.setDataField<double>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool LearningControlEvidence::NamedValue::Reader::isText() const {
  return which() == LearningControlEvidence::NamedValue::TEXT;
}
inline bool LearningControlEvidence::NamedValue::Builder::isText() {
  return which() == LearningControlEvidence::NamedValue::TEXT;
}
inline bool LearningControlEvidence::NamedValue::Reader::hasText() const {
  if (which() != LearningControlEvidence::NamedValue::TEXT) return false;
  return !_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline bool LearningControlEvidence::NamedValue::Builder::hasText() {
  if (which() != LearningControlEvidence::NamedValue::TEXT) return false;
  return !_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader LearningControlEvidence::NamedValue::Reader::getText() const {
  KJ_IREQUIRE((which() == LearningControlEvidence::NamedValue::TEXT),
              "Must check which() before get()ing a union member.");
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder LearningControlEvidence::NamedValue::Builder::getText() {
  KJ_IREQUIRE((which() == LearningControlEvidence::NamedValue::TEXT),
              "Must check which() before get()ing a union member.");
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline void LearningControlEvidence::NamedValue::Builder::setText( ::capnp::Text::Reader value) {
  _builder.setDataField<LearningControlEvidence::NamedValue::Which>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS, LearningControlEvidence::NamedValue::TEXT);
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder LearningControlEvidence::NamedValue::Builder::initText(unsigned int size) {
  _builder.setDataField<LearningControlEvidence::NamedValue::Which>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS, LearningControlEvidence::NamedValue::TEXT);
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), size);
}
inline void LearningControlEvidence::NamedValue::Builder::adoptText(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  _builder.setDataField<LearningControlEvidence::NamedValue::Which>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS, LearningControlEvidence::NamedValue::TEXT);
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> LearningControlEvidence::NamedValue::Builder::disownText() {
  KJ_IREQUIRE((which() == LearningControlEvidence::NamedValue::TEXT),
              "Must check which() before get()ing a union member.");
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}

inline bool LearningControlEvidence::NamedValue::Reader::isBoolean() const {
  return which() == LearningControlEvidence::NamedValue::BOOLEAN;
}
inline bool LearningControlEvidence::NamedValue::Builder::isBoolean() {
  return which() == LearningControlEvidence::NamedValue::BOOLEAN;
}
inline bool LearningControlEvidence::NamedValue::Reader::getBoolean() const {
  KJ_IREQUIRE((which() == LearningControlEvidence::NamedValue::BOOLEAN),
              "Must check which() before get()ing a union member.");
  return _reader.getDataField<bool>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline bool LearningControlEvidence::NamedValue::Builder::getBoolean() {
  KJ_IREQUIRE((which() == LearningControlEvidence::NamedValue::BOOLEAN),
              "Must check which() before get()ing a union member.");
  return _builder.getDataField<bool>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void LearningControlEvidence::NamedValue::Builder::setBoolean(bool value) {
  _builder.setDataField<LearningControlEvidence::NamedValue::Which>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS, LearningControlEvidence::NamedValue::BOOLEAN);
  _builder.setDataField<bool>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool LearningControlEvidence::StageValue::Reader::hasName() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool LearningControlEvidence::StageValue::Builder::hasName() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader LearningControlEvidence::StageValue::Reader::getName() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder LearningControlEvidence::StageValue::Builder::getName() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void LearningControlEvidence::StageValue::Builder::setName( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder LearningControlEvidence::StageValue::Builder::initName(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void LearningControlEvidence::StageValue::Builder::adoptName(
    ::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> LearningControlEvidence::StageValue::Builder::disownName() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline double LearningControlEvidence::StageValue::Reader::getValue() const {
  return _reader.getDataField<double>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline double LearningControlEvidence::StageValue::Builder::getValue() {
  return _builder.getDataField<double>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void LearningControlEvidence::StageValue::Builder::setValue(double value) {
  _builder.setDataField<double>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline  ::uint16_t LearningAppliedEvidence::Reader::getVersion() const {
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline  ::uint16_t LearningAppliedEvidence::Builder::getVersion() {
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void LearningAppliedEvidence::Builder::setVersion( ::uint16_t value) {
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t LearningAppliedEvidence::Reader::getControlMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t LearningAppliedEvidence::Builder::getControlMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void LearningAppliedEvidence::Builder::setControlMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t LearningAppliedEvidence::Reader::getSourceStateMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t LearningAppliedEvidence::Builder::getSourceStateMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void LearningAppliedEvidence::Builder::setSourceStateMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t LearningAppliedEvidence::Reader::getAppliedMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t LearningAppliedEvidence::Builder::getAppliedMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}
inline void LearningAppliedEvidence::Builder::setAppliedMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS, value);
}

inline bool LearningAppliedEvidence::Reader::hasDomain() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool LearningAppliedEvidence::Builder::hasDomain() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader LearningAppliedEvidence::Reader::getDomain() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder LearningAppliedEvidence::Builder::getDomain() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void LearningAppliedEvidence::Builder::setDomain( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder LearningAppliedEvidence::Builder::initDomain(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void LearningAppliedEvidence::Builder::adoptDomain(
    ::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> LearningAppliedEvidence::Builder::disownDomain() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline double LearningAppliedEvidence::Reader::getApplied() const {
  return _reader.getDataField<double>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}

inline double LearningAppliedEvidence::Builder::getApplied() {
  return _builder.getDataField<double>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}
inline void LearningAppliedEvidence::Builder::setApplied(double value) {
  _builder.setDataField<double>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS, value);
}

inline bool LearningAppliedEvidence::Reader::getValid() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS);
}

inline bool LearningAppliedEvidence::Builder::getValid() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS);
}
inline void LearningAppliedEvidence::Builder::setValid(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS, value);
}

inline bool LearningAppliedEvidence::Reader::getActive() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<17>() * ::capnp::ELEMENTS);
}

inline bool LearningAppliedEvidence::Builder::getActive() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<17>() * ::capnp::ELEMENTS);
}
inline void LearningAppliedEvidence::Builder::setActive(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<17>() * ::capnp::ELEMENTS, value);
}

inline bool LearningAppliedEvidence::Reader::getOverride() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<18>() * ::capnp::ELEMENTS);
}

inline bool LearningAppliedEvidence::Builder::getOverride() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<18>() * ::capnp::ELEMENTS);
}
inline void LearningAppliedEvidence::Builder::setOverride(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<18>() * ::capnp::ELEMENTS, value);
}

inline bool LearningAppliedEvidence::Reader::getFault() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<19>() * ::capnp::ELEMENTS);
}

inline bool LearningAppliedEvidence::Builder::getFault() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<19>() * ::capnp::ELEMENTS);
}
inline void LearningAppliedEvidence::Builder::setFault(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<19>() * ::capnp::ELEMENTS, value);
}

inline bool LearningAppliedEvidence::Reader::getLimited() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<20>() * ::capnp::ELEMENTS);
}

inline bool LearningAppliedEvidence::Builder::getLimited() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<20>() * ::capnp::ELEMENTS);
}
inline void LearningAppliedEvidence::Builder::setLimited(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<20>() * ::capnp::ELEMENTS, value);
}

inline bool LearningAppliedEvidence::Reader::getNativeAllowed() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<21>() * ::capnp::ELEMENTS);
}

inline bool LearningAppliedEvidence::Builder::getNativeAllowed() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<21>() * ::capnp::ELEMENTS);
}
inline void LearningAppliedEvidence::Builder::setNativeAllowed(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<21>() * ::capnp::ELEMENTS, value);
}

inline bool LearningAppliedEvidence::Reader::hasProjection() const {
  return !_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline bool LearningAppliedEvidence::Builder::hasProjection() {
  return !_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline  ::cereal::LearningTorqueProjection::Reader LearningAppliedEvidence::Reader::getProjection() const {
  return ::capnp::_::PointerHelpers< ::cereal::LearningTorqueProjection>::get(_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline  ::cereal::LearningTorqueProjection::Builder LearningAppliedEvidence::Builder::getProjection() {
  return ::capnp::_::PointerHelpers< ::cereal::LearningTorqueProjection>::get(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
#if !CAPNP_LITE
inline  ::cereal::LearningTorqueProjection::Pipeline LearningAppliedEvidence::Pipeline::getProjection() {
  return  ::cereal::LearningTorqueProjection::Pipeline(_typeless.getPointerField(1));
}
#endif  // !CAPNP_LITE
inline void LearningAppliedEvidence::Builder::setProjection( ::cereal::LearningTorqueProjection::Reader value) {
  ::capnp::_::PointerHelpers< ::cereal::LearningTorqueProjection>::set(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), value);
}
inline  ::cereal::LearningTorqueProjection::Builder LearningAppliedEvidence::Builder::initProjection() {
  return ::capnp::_::PointerHelpers< ::cereal::LearningTorqueProjection>::init(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline void LearningAppliedEvidence::Builder::adoptProjection(
    ::capnp::Orphan< ::cereal::LearningTorqueProjection>&& value) {
  ::capnp::_::PointerHelpers< ::cereal::LearningTorqueProjection>::adopt(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::cereal::LearningTorqueProjection> LearningAppliedEvidence::Builder::disownProjection() {
  return ::capnp::_::PointerHelpers< ::cereal::LearningTorqueProjection>::disown(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}

inline  ::uint64_t LearningAppliedEvidence::Reader::getCarrierFrame() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t LearningAppliedEvidence::Builder::getCarrierFrame() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}
inline void LearningAppliedEvidence::Builder::setCarrierFrame( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t LearningAppliedEvidence::Reader::getCarrierObservedMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t LearningAppliedEvidence::Builder::getCarrierObservedMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS);
}
inline void LearningAppliedEvidence::Builder::setCarrierObservedMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS, value);
}

inline  ::uint16_t AutomaticRuntimeProfile::Reader::getVersion() const {
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline  ::uint16_t AutomaticRuntimeProfile::Builder::getVersion() {
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void AutomaticRuntimeProfile::Builder::setVersion( ::uint16_t value) {
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool AutomaticRuntimeProfile::Reader::hasIdentity() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool AutomaticRuntimeProfile::Builder::hasIdentity() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader AutomaticRuntimeProfile::Reader::getIdentity() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder AutomaticRuntimeProfile::Builder::getIdentity() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void AutomaticRuntimeProfile::Builder::setIdentity( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder AutomaticRuntimeProfile::Builder::initIdentity(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void AutomaticRuntimeProfile::Builder::adoptIdentity(
    ::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> AutomaticRuntimeProfile::Builder::disownIdentity() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline  ::uint64_t AutomaticRuntimeProfile::Reader::getSequence() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t AutomaticRuntimeProfile::Builder::getSequence() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void AutomaticRuntimeProfile::Builder::setSequence( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t AutomaticRuntimeProfile::Reader::getObservedMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t AutomaticRuntimeProfile::Builder::getObservedMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void AutomaticRuntimeProfile::Builder::setObservedMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t AutomaticRuntimeProfile::Reader::getValidUntilMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t AutomaticRuntimeProfile::Builder::getValidUntilMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}
inline void AutomaticRuntimeProfile::Builder::setValidUntilMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS, value);
}

inline bool AutomaticRuntimeProfile::Reader::hasPolicy() const {
  return !_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline bool AutomaticRuntimeProfile::Builder::hasPolicy() {
  return !_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader AutomaticRuntimeProfile::Reader::getPolicy() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder AutomaticRuntimeProfile::Builder::getPolicy() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline void AutomaticRuntimeProfile::Builder::setPolicy( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder AutomaticRuntimeProfile::Builder::initPolicy(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), size);
}
inline void AutomaticRuntimeProfile::Builder::adoptPolicy(
    ::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> AutomaticRuntimeProfile::Builder::disownPolicy() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}

inline bool AutomaticRuntimeProfile::Reader::hasParameters() const {
  return !_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline bool AutomaticRuntimeProfile::Builder::hasParameters() {
  return !_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::List< ::cereal::AutomaticRuntimeProfile::Parameter,  ::capnp::Kind::STRUCT>::Reader AutomaticRuntimeProfile::Reader::getParameters() const {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::AutomaticRuntimeProfile::Parameter,  ::capnp::Kind::STRUCT>>::get(_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline  ::capnp::List< ::cereal::AutomaticRuntimeProfile::Parameter,  ::capnp::Kind::STRUCT>::Builder AutomaticRuntimeProfile::Builder::getParameters() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::AutomaticRuntimeProfile::Parameter,  ::capnp::Kind::STRUCT>>::get(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline void AutomaticRuntimeProfile::Builder::setParameters( ::capnp::List< ::cereal::AutomaticRuntimeProfile::Parameter,  ::capnp::Kind::STRUCT>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::AutomaticRuntimeProfile::Parameter,  ::capnp::Kind::STRUCT>>::set(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), value);
}
inline  ::capnp::List< ::cereal::AutomaticRuntimeProfile::Parameter,  ::capnp::Kind::STRUCT>::Builder AutomaticRuntimeProfile::Builder::initParameters(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::AutomaticRuntimeProfile::Parameter,  ::capnp::Kind::STRUCT>>::init(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), size);
}
inline void AutomaticRuntimeProfile::Builder::adoptParameters(
    ::capnp::Orphan< ::capnp::List< ::cereal::AutomaticRuntimeProfile::Parameter,  ::capnp::Kind::STRUCT>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::AutomaticRuntimeProfile::Parameter,  ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List< ::cereal::AutomaticRuntimeProfile::Parameter,  ::capnp::Kind::STRUCT>> AutomaticRuntimeProfile::Builder::disownParameters() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::AutomaticRuntimeProfile::Parameter,  ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}

inline bool AutomaticRuntimeProfile::Reader::hasCoefficients() const {
  return !_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline bool AutomaticRuntimeProfile::Builder::hasCoefficients() {
  return !_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Reader AutomaticRuntimeProfile::Reader::getCoefficients() const {
  return ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Builder AutomaticRuntimeProfile::Builder::getCoefficients() {
  return ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline void AutomaticRuntimeProfile::Builder::setCoefficients( ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), value);
}
inline void AutomaticRuntimeProfile::Builder::setCoefficients(::kj::ArrayPtr<const double> value) {
  ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), value);
}
inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Builder AutomaticRuntimeProfile::Builder::initCoefficients(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), size);
}
inline void AutomaticRuntimeProfile::Builder::adoptCoefficients(
    ::capnp::Orphan< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>> AutomaticRuntimeProfile::Builder::disownCoefficients() {
  return ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}

inline bool AutomaticRuntimeProfile::Reader::hasTrainIds() const {
  return !_reader.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS).isNull();
}
inline bool AutomaticRuntimeProfile::Builder::hasTrainIds() {
  return !_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>::Reader AutomaticRuntimeProfile::Reader::getTrainIds() const {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>::get(_reader.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}
inline  ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>::Builder AutomaticRuntimeProfile::Builder::getTrainIds() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>::get(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}
inline void AutomaticRuntimeProfile::Builder::setTrainIds( ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>::set(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), value);
}
inline void AutomaticRuntimeProfile::Builder::setTrainIds(::kj::ArrayPtr<const  ::capnp::Text::Reader> value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>::set(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), value);
}
inline  ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>::Builder AutomaticRuntimeProfile::Builder::initTrainIds(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>::init(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), size);
}
inline void AutomaticRuntimeProfile::Builder::adoptTrainIds(
    ::capnp::Orphan< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>::adopt(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>> AutomaticRuntimeProfile::Builder::disownTrainIds() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>::disown(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}

inline bool AutomaticRuntimeProfile::Reader::hasHeldoutIds() const {
  return !_reader.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS).isNull();
}
inline bool AutomaticRuntimeProfile::Builder::hasHeldoutIds() {
  return !_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>::Reader AutomaticRuntimeProfile::Reader::getHeldoutIds() const {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>::get(_reader.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS));
}
inline  ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>::Builder AutomaticRuntimeProfile::Builder::getHeldoutIds() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>::get(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS));
}
inline void AutomaticRuntimeProfile::Builder::setHeldoutIds( ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>::set(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS), value);
}
inline void AutomaticRuntimeProfile::Builder::setHeldoutIds(::kj::ArrayPtr<const  ::capnp::Text::Reader> value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>::set(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS), value);
}
inline  ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>::Builder AutomaticRuntimeProfile::Builder::initHeldoutIds(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>::init(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS), size);
}
inline void AutomaticRuntimeProfile::Builder::adoptHeldoutIds(
    ::capnp::Orphan< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>::adopt(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>> AutomaticRuntimeProfile::Builder::disownHeldoutIds() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>::disown(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS));
}

inline double AutomaticRuntimeProfile::Reader::getBaselineLoss() const {
  return _reader.getDataField<double>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}

inline double AutomaticRuntimeProfile::Builder::getBaselineLoss() {
  return _builder.getDataField<double>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}
inline void AutomaticRuntimeProfile::Builder::setBaselineLoss(double value) {
  _builder.setDataField<double>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS, value);
}

inline double AutomaticRuntimeProfile::Reader::getCandidateLoss() const {
  return _reader.getDataField<double>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}

inline double AutomaticRuntimeProfile::Builder::getCandidateLoss() {
  return _builder.getDataField<double>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}
inline void AutomaticRuntimeProfile::Builder::setCandidateLoss(double value) {
  _builder.setDataField<double>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS, value);
}

inline bool AutomaticRuntimeProfile::Reader::hasCohortImprovements() const {
  return !_reader.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS).isNull();
}
inline bool AutomaticRuntimeProfile::Builder::hasCohortImprovements() {
  return !_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::List< ::cereal::AutomaticRuntimeProfile::CohortImprovement,  ::capnp::Kind::STRUCT>::Reader AutomaticRuntimeProfile::Reader::getCohortImprovements() const {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::AutomaticRuntimeProfile::CohortImprovement,  ::capnp::Kind::STRUCT>>::get(_reader.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS));
}
inline  ::capnp::List< ::cereal::AutomaticRuntimeProfile::CohortImprovement,  ::capnp::Kind::STRUCT>::Builder AutomaticRuntimeProfile::Builder::getCohortImprovements() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::AutomaticRuntimeProfile::CohortImprovement,  ::capnp::Kind::STRUCT>>::get(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS));
}
inline void AutomaticRuntimeProfile::Builder::setCohortImprovements( ::capnp::List< ::cereal::AutomaticRuntimeProfile::CohortImprovement,  ::capnp::Kind::STRUCT>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::AutomaticRuntimeProfile::CohortImprovement,  ::capnp::Kind::STRUCT>>::set(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS), value);
}
inline  ::capnp::List< ::cereal::AutomaticRuntimeProfile::CohortImprovement,  ::capnp::Kind::STRUCT>::Builder AutomaticRuntimeProfile::Builder::initCohortImprovements(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::AutomaticRuntimeProfile::CohortImprovement,  ::capnp::Kind::STRUCT>>::init(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS), size);
}
inline void AutomaticRuntimeProfile::Builder::adoptCohortImprovements(
    ::capnp::Orphan< ::capnp::List< ::cereal::AutomaticRuntimeProfile::CohortImprovement,  ::capnp::Kind::STRUCT>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::AutomaticRuntimeProfile::CohortImprovement,  ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List< ::cereal::AutomaticRuntimeProfile::CohortImprovement,  ::capnp::Kind::STRUCT>> AutomaticRuntimeProfile::Builder::disownCohortImprovements() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::AutomaticRuntimeProfile::CohortImprovement,  ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS));
}

inline bool AutomaticRuntimeProfile::Reader::hasReplay() const {
  return !_reader.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS).isNull();
}
inline bool AutomaticRuntimeProfile::Builder::hasReplay() {
  return !_builder.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS).isNull();
}
inline  ::cereal::AutomaticRuntimeProfile::ReplayValidation::Reader AutomaticRuntimeProfile::Reader::getReplay() const {
  return ::capnp::_::PointerHelpers< ::cereal::AutomaticRuntimeProfile::ReplayValidation>::get(_reader.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS));
}
inline  ::cereal::AutomaticRuntimeProfile::ReplayValidation::Builder AutomaticRuntimeProfile::Builder::getReplay() {
  return ::capnp::_::PointerHelpers< ::cereal::AutomaticRuntimeProfile::ReplayValidation>::get(_builder.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS));
}
#if !CAPNP_LITE
inline  ::cereal::AutomaticRuntimeProfile::ReplayValidation::Pipeline AutomaticRuntimeProfile::Pipeline::getReplay() {
  return  ::cereal::AutomaticRuntimeProfile::ReplayValidation::Pipeline(_typeless.getPointerField(7));
}
#endif  // !CAPNP_LITE
inline void AutomaticRuntimeProfile::Builder::setReplay( ::cereal::AutomaticRuntimeProfile::ReplayValidation::Reader value) {
  ::capnp::_::PointerHelpers< ::cereal::AutomaticRuntimeProfile::ReplayValidation>::set(_builder.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS), value);
}
inline  ::cereal::AutomaticRuntimeProfile::ReplayValidation::Builder AutomaticRuntimeProfile::Builder::initReplay() {
  return ::capnp::_::PointerHelpers< ::cereal::AutomaticRuntimeProfile::ReplayValidation>::init(_builder.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS));
}
inline void AutomaticRuntimeProfile::Builder::adoptReplay(
    ::capnp::Orphan< ::cereal::AutomaticRuntimeProfile::ReplayValidation>&& value) {
  ::capnp::_::PointerHelpers< ::cereal::AutomaticRuntimeProfile::ReplayValidation>::adopt(_builder.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::cereal::AutomaticRuntimeProfile::ReplayValidation> AutomaticRuntimeProfile::Builder::disownReplay() {
  return ::capnp::_::PointerHelpers< ::cereal::AutomaticRuntimeProfile::ReplayValidation>::disown(_builder.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS));
}

inline bool AutomaticRuntimeProfile::Reader::hasFullSurface() const {
  return !_reader.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS).isNull();
}
inline bool AutomaticRuntimeProfile::Builder::hasFullSurface() {
  return !_builder.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS).isNull();
}
inline  ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope::Reader AutomaticRuntimeProfile::Reader::getFullSurface() const {
  return ::capnp::_::PointerHelpers< ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope>::get(_reader.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS));
}
inline  ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder AutomaticRuntimeProfile::Builder::getFullSurface() {
  return ::capnp::_::PointerHelpers< ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope>::get(_builder.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS));
}
#if !CAPNP_LITE
inline  ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope::Pipeline AutomaticRuntimeProfile::Pipeline::getFullSurface() {
  return  ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope::Pipeline(_typeless.getPointerField(8));
}
#endif  // !CAPNP_LITE
inline void AutomaticRuntimeProfile::Builder::setFullSurface( ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope::Reader value) {
  ::capnp::_::PointerHelpers< ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope>::set(_builder.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS), value);
}
inline  ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder AutomaticRuntimeProfile::Builder::initFullSurface() {
  return ::capnp::_::PointerHelpers< ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope>::init(_builder.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS));
}
inline void AutomaticRuntimeProfile::Builder::adoptFullSurface(
    ::capnp::Orphan< ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope>&& value) {
  ::capnp::_::PointerHelpers< ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope>::adopt(_builder.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope> AutomaticRuntimeProfile::Builder::disownFullSurface() {
  return ::capnp::_::PointerHelpers< ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope>::disown(_builder.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS));
}

inline  ::uint16_t AutomaticRuntimeProfile::FullSurfaceEnvelope::Reader::getVersion() const {
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline  ::uint16_t AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::getVersion() {
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::setVersion( ::uint16_t value) {
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool AutomaticRuntimeProfile::FullSurfaceEnvelope::Reader::hasManifestSha256() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::hasManifestSha256() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader AutomaticRuntimeProfile::FullSurfaceEnvelope::Reader::getManifestSha256() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::getManifestSha256() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::setManifestSha256( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::initManifestSha256(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::adoptManifestSha256(
    ::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> AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::disownManifestSha256() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline bool AutomaticRuntimeProfile::FullSurfaceEnvelope::Reader::hasFullOriginalAnchor() const {
  return !_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline bool AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::hasFullOriginalAnchor() {
  return !_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader AutomaticRuntimeProfile::FullSurfaceEnvelope::Reader::getFullOriginalAnchor() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::getFullOriginalAnchor() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline void AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::setFullOriginalAnchor( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::initFullOriginalAnchor(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), size);
}
inline void AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::adoptFullOriginalAnchor(
    ::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> AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::disownFullOriginalAnchor() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}

inline bool AutomaticRuntimeProfile::FullSurfaceEnvelope::Reader::hasTrialAnchor() const {
  return !_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline bool AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::hasTrialAnchor() {
  return !_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader AutomaticRuntimeProfile::FullSurfaceEnvelope::Reader::getTrialAnchor() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::getTrialAnchor() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline void AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::setTrialAnchor( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::initTrialAnchor(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), size);
}
inline void AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::adoptTrialAnchor(
    ::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> AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::disownTrialAnchor() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}

inline bool AutomaticRuntimeProfile::FullSurfaceEnvelope::Reader::hasContextKey() const {
  return !_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline bool AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::hasContextKey() {
  return !_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader AutomaticRuntimeProfile::FullSurfaceEnvelope::Reader::getContextKey() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::getContextKey() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline void AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::setContextKey( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::initContextKey(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), size);
}
inline void AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::adoptContextKey(
    ::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> AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::disownContextKey() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}

inline bool AutomaticRuntimeProfile::FullSurfaceEnvelope::Reader::hasCpSha256() const {
  return !_reader.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS).isNull();
}
inline bool AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::hasCpSha256() {
  return !_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader AutomaticRuntimeProfile::FullSurfaceEnvelope::Reader::getCpSha256() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::getCpSha256() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}
inline void AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::setCpSha256( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::initCpSha256(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), size);
}
inline void AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::adoptCpSha256(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::disownCpSha256() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}

inline bool AutomaticRuntimeProfile::FullSurfaceEnvelope::Reader::hasControllerRevision() const {
  return !_reader.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS).isNull();
}
inline bool AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::hasControllerRevision() {
  return !_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader AutomaticRuntimeProfile::FullSurfaceEnvelope::Reader::getControllerRevision() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::getControllerRevision() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS));
}
inline void AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::setControllerRevision( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::initControllerRevision(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS), size);
}
inline void AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::adoptControllerRevision(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::disownControllerRevision() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS));
}

inline bool AutomaticRuntimeProfile::FullSurfaceEnvelope::Reader::hasSourceEpoch() const {
  return !_reader.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS).isNull();
}
inline bool AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::hasSourceEpoch() {
  return !_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader AutomaticRuntimeProfile::FullSurfaceEnvelope::Reader::getSourceEpoch() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::getSourceEpoch() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS));
}
inline void AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::setSourceEpoch( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::initSourceEpoch(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS), size);
}
inline void AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::adoptSourceEpoch(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::disownSourceEpoch() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS));
}

inline bool AutomaticRuntimeProfile::FullSurfaceEnvelope::Reader::hasResetGeneration() const {
  return !_reader.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS).isNull();
}
inline bool AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::hasResetGeneration() {
  return !_builder.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader AutomaticRuntimeProfile::FullSurfaceEnvelope::Reader::getResetGeneration() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::getResetGeneration() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS));
}
inline void AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::setResetGeneration( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::initResetGeneration(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS), size);
}
inline void AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::adoptResetGeneration(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::disownResetGeneration() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS));
}

inline bool AutomaticRuntimeProfile::FullSurfaceEnvelope::Reader::hasSelectedBaselineRevision() const {
  return !_reader.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS).isNull();
}
inline bool AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::hasSelectedBaselineRevision() {
  return !_builder.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader AutomaticRuntimeProfile::FullSurfaceEnvelope::Reader::getSelectedBaselineRevision() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::getSelectedBaselineRevision() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS));
}
inline void AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::setSelectedBaselineRevision( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::initSelectedBaselineRevision(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS), size);
}
inline void AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::adoptSelectedBaselineRevision(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::disownSelectedBaselineRevision() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS));
}

inline bool AutomaticRuntimeProfile::FullSurfaceEnvelope::Reader::hasPriorFullProfileSha256() const {
  return !_reader.getPointerField(
      ::capnp::bounded<9>() * ::capnp::POINTERS).isNull();
}
inline bool AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::hasPriorFullProfileSha256() {
  return !_builder.getPointerField(
      ::capnp::bounded<9>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader AutomaticRuntimeProfile::FullSurfaceEnvelope::Reader::getPriorFullProfileSha256() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<9>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::getPriorFullProfileSha256() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<9>() * ::capnp::POINTERS));
}
inline void AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::setPriorFullProfileSha256( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<9>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::initPriorFullProfileSha256(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<9>() * ::capnp::POINTERS), size);
}
inline void AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::adoptPriorFullProfileSha256(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<9>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::disownPriorFullProfileSha256() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<9>() * ::capnp::POINTERS));
}

inline bool AutomaticRuntimeProfile::FullSurfaceEnvelope::Reader::hasFullProfileSha256() const {
  return !_reader.getPointerField(
      ::capnp::bounded<10>() * ::capnp::POINTERS).isNull();
}
inline bool AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::hasFullProfileSha256() {
  return !_builder.getPointerField(
      ::capnp::bounded<10>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader AutomaticRuntimeProfile::FullSurfaceEnvelope::Reader::getFullProfileSha256() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<10>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::getFullProfileSha256() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<10>() * ::capnp::POINTERS));
}
inline void AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::setFullProfileSha256( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<10>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::initFullProfileSha256(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<10>() * ::capnp::POINTERS), size);
}
inline void AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::adoptFullProfileSha256(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<10>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::disownFullProfileSha256() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<10>() * ::capnp::POINTERS));
}

inline bool AutomaticRuntimeProfile::FullSurfaceEnvelope::Reader::hasPriorCoordinates() const {
  return !_reader.getPointerField(
      ::capnp::bounded<11>() * ::capnp::POINTERS).isNull();
}
inline bool AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::hasPriorCoordinates() {
  return !_builder.getPointerField(
      ::capnp::bounded<11>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::List< ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope::Coordinate,  ::capnp::Kind::STRUCT>::Reader AutomaticRuntimeProfile::FullSurfaceEnvelope::Reader::getPriorCoordinates() const {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope::Coordinate,  ::capnp::Kind::STRUCT>>::get(_reader.getPointerField(
      ::capnp::bounded<11>() * ::capnp::POINTERS));
}
inline  ::capnp::List< ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope::Coordinate,  ::capnp::Kind::STRUCT>::Builder AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::getPriorCoordinates() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope::Coordinate,  ::capnp::Kind::STRUCT>>::get(_builder.getPointerField(
      ::capnp::bounded<11>() * ::capnp::POINTERS));
}
inline void AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::setPriorCoordinates( ::capnp::List< ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope::Coordinate,  ::capnp::Kind::STRUCT>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope::Coordinate,  ::capnp::Kind::STRUCT>>::set(_builder.getPointerField(
      ::capnp::bounded<11>() * ::capnp::POINTERS), value);
}
inline  ::capnp::List< ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope::Coordinate,  ::capnp::Kind::STRUCT>::Builder AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::initPriorCoordinates(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope::Coordinate,  ::capnp::Kind::STRUCT>>::init(_builder.getPointerField(
      ::capnp::bounded<11>() * ::capnp::POINTERS), size);
}
inline void AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::adoptPriorCoordinates(
    ::capnp::Orphan< ::capnp::List< ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope::Coordinate,  ::capnp::Kind::STRUCT>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope::Coordinate,  ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField(
      ::capnp::bounded<11>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List< ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope::Coordinate,  ::capnp::Kind::STRUCT>> AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::disownPriorCoordinates() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope::Coordinate,  ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField(
      ::capnp::bounded<11>() * ::capnp::POINTERS));
}

inline bool AutomaticRuntimeProfile::FullSurfaceEnvelope::Reader::hasCoordinates() const {
  return !_reader.getPointerField(
      ::capnp::bounded<12>() * ::capnp::POINTERS).isNull();
}
inline bool AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::hasCoordinates() {
  return !_builder.getPointerField(
      ::capnp::bounded<12>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::List< ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope::Coordinate,  ::capnp::Kind::STRUCT>::Reader AutomaticRuntimeProfile::FullSurfaceEnvelope::Reader::getCoordinates() const {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope::Coordinate,  ::capnp::Kind::STRUCT>>::get(_reader.getPointerField(
      ::capnp::bounded<12>() * ::capnp::POINTERS));
}
inline  ::capnp::List< ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope::Coordinate,  ::capnp::Kind::STRUCT>::Builder AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::getCoordinates() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope::Coordinate,  ::capnp::Kind::STRUCT>>::get(_builder.getPointerField(
      ::capnp::bounded<12>() * ::capnp::POINTERS));
}
inline void AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::setCoordinates( ::capnp::List< ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope::Coordinate,  ::capnp::Kind::STRUCT>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope::Coordinate,  ::capnp::Kind::STRUCT>>::set(_builder.getPointerField(
      ::capnp::bounded<12>() * ::capnp::POINTERS), value);
}
inline  ::capnp::List< ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope::Coordinate,  ::capnp::Kind::STRUCT>::Builder AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::initCoordinates(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope::Coordinate,  ::capnp::Kind::STRUCT>>::init(_builder.getPointerField(
      ::capnp::bounded<12>() * ::capnp::POINTERS), size);
}
inline void AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::adoptCoordinates(
    ::capnp::Orphan< ::capnp::List< ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope::Coordinate,  ::capnp::Kind::STRUCT>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope::Coordinate,  ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField(
      ::capnp::bounded<12>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List< ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope::Coordinate,  ::capnp::Kind::STRUCT>> AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::disownCoordinates() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::AutomaticRuntimeProfile::FullSurfaceEnvelope::Coordinate,  ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField(
      ::capnp::bounded<12>() * ::capnp::POINTERS));
}

inline bool AutomaticRuntimeProfile::FullSurfaceEnvelope::Reader::hasTrialNames() const {
  return !_reader.getPointerField(
      ::capnp::bounded<13>() * ::capnp::POINTERS).isNull();
}
inline bool AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::hasTrialNames() {
  return !_builder.getPointerField(
      ::capnp::bounded<13>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>::Reader AutomaticRuntimeProfile::FullSurfaceEnvelope::Reader::getTrialNames() const {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>::get(_reader.getPointerField(
      ::capnp::bounded<13>() * ::capnp::POINTERS));
}
inline  ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>::Builder AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::getTrialNames() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>::get(_builder.getPointerField(
      ::capnp::bounded<13>() * ::capnp::POINTERS));
}
inline void AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::setTrialNames( ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>::set(_builder.getPointerField(
      ::capnp::bounded<13>() * ::capnp::POINTERS), value);
}
inline void AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::setTrialNames(::kj::ArrayPtr<const  ::capnp::Text::Reader> value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>::set(_builder.getPointerField(
      ::capnp::bounded<13>() * ::capnp::POINTERS), value);
}
inline  ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>::Builder AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::initTrialNames(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>::init(_builder.getPointerField(
      ::capnp::bounded<13>() * ::capnp::POINTERS), size);
}
inline void AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::adoptTrialNames(
    ::capnp::Orphan< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>::adopt(_builder.getPointerField(
      ::capnp::bounded<13>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>> AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::disownTrialNames() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>::disown(_builder.getPointerField(
      ::capnp::bounded<13>() * ::capnp::POINTERS));
}

inline bool AutomaticRuntimeProfile::FullSurfaceEnvelope::Reader::hasPersistentSourceEpoch() const {
  return !_reader.getPointerField(
      ::capnp::bounded<14>() * ::capnp::POINTERS).isNull();
}
inline bool AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::hasPersistentSourceEpoch() {
  return !_builder.getPointerField(
      ::capnp::bounded<14>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader AutomaticRuntimeProfile::FullSurfaceEnvelope::Reader::getPersistentSourceEpoch() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<14>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::getPersistentSourceEpoch() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<14>() * ::capnp::POINTERS));
}
inline void AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::setPersistentSourceEpoch( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<14>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::initPersistentSourceEpoch(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<14>() * ::capnp::POINTERS), size);
}
inline void AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::adoptPersistentSourceEpoch(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<14>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::disownPersistentSourceEpoch() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<14>() * ::capnp::POINTERS));
}

inline bool AutomaticRuntimeProfile::FullSurfaceEnvelope::Reader::hasOperation() const {
  return !_reader.getPointerField(
      ::capnp::bounded<15>() * ::capnp::POINTERS).isNull();
}
inline bool AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::hasOperation() {
  return !_builder.getPointerField(
      ::capnp::bounded<15>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader AutomaticRuntimeProfile::FullSurfaceEnvelope::Reader::getOperation() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<15>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::getOperation() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<15>() * ::capnp::POINTERS));
}
inline void AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::setOperation( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<15>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::initOperation(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<15>() * ::capnp::POINTERS), size);
}
inline void AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::adoptOperation(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<15>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::disownOperation() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<15>() * ::capnp::POINTERS));
}

inline bool AutomaticRuntimeProfile::FullSurfaceEnvelope::Reader::hasHistoryFullProfileSha256() const {
  return !_reader.getPointerField(
      ::capnp::bounded<16>() * ::capnp::POINTERS).isNull();
}
inline bool AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::hasHistoryFullProfileSha256() {
  return !_builder.getPointerField(
      ::capnp::bounded<16>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader AutomaticRuntimeProfile::FullSurfaceEnvelope::Reader::getHistoryFullProfileSha256() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<16>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::getHistoryFullProfileSha256() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<16>() * ::capnp::POINTERS));
}
inline void AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::setHistoryFullProfileSha256( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<16>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::initHistoryFullProfileSha256(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<16>() * ::capnp::POINTERS), size);
}
inline void AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::adoptHistoryFullProfileSha256(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<16>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::disownHistoryFullProfileSha256() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<16>() * ::capnp::POINTERS));
}

inline bool AutomaticRuntimeProfile::FullSurfaceEnvelope::Reader::hasRestoreTransactionSha256() const {
  return !_reader.getPointerField(
      ::capnp::bounded<17>() * ::capnp::POINTERS).isNull();
}
inline bool AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::hasRestoreTransactionSha256() {
  return !_builder.getPointerField(
      ::capnp::bounded<17>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader AutomaticRuntimeProfile::FullSurfaceEnvelope::Reader::getRestoreTransactionSha256() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<17>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::getRestoreTransactionSha256() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<17>() * ::capnp::POINTERS));
}
inline void AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::setRestoreTransactionSha256( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<17>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::initRestoreTransactionSha256(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<17>() * ::capnp::POINTERS), size);
}
inline void AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::adoptRestoreTransactionSha256(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<17>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> AutomaticRuntimeProfile::FullSurfaceEnvelope::Builder::disownRestoreTransactionSha256() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<17>() * ::capnp::POINTERS));
}

inline bool AutomaticRuntimeProfile::FullSurfaceEnvelope::Coordinate::Reader::hasName() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool AutomaticRuntimeProfile::FullSurfaceEnvelope::Coordinate::Builder::hasName() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader AutomaticRuntimeProfile::FullSurfaceEnvelope::Coordinate::Reader::getName() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder AutomaticRuntimeProfile::FullSurfaceEnvelope::Coordinate::Builder::getName() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void AutomaticRuntimeProfile::FullSurfaceEnvelope::Coordinate::Builder::setName( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder AutomaticRuntimeProfile::FullSurfaceEnvelope::Coordinate::Builder::initName(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void AutomaticRuntimeProfile::FullSurfaceEnvelope::Coordinate::Builder::adoptName(
    ::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> AutomaticRuntimeProfile::FullSurfaceEnvelope::Coordinate::Builder::disownName() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline double AutomaticRuntimeProfile::FullSurfaceEnvelope::Coordinate::Reader::getValue() const {
  return _reader.getDataField<double>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline double AutomaticRuntimeProfile::FullSurfaceEnvelope::Coordinate::Builder::getValue() {
  return _builder.getDataField<double>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void AutomaticRuntimeProfile::FullSurfaceEnvelope::Coordinate::Builder::setValue(double value) {
  _builder.setDataField<double>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool AutomaticRuntimeProfile::ReplayValidation::Reader::hasBaselineRevision() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool AutomaticRuntimeProfile::ReplayValidation::Builder::hasBaselineRevision() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader AutomaticRuntimeProfile::ReplayValidation::Reader::getBaselineRevision() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder AutomaticRuntimeProfile::ReplayValidation::Builder::getBaselineRevision() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void AutomaticRuntimeProfile::ReplayValidation::Builder::setBaselineRevision( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder AutomaticRuntimeProfile::ReplayValidation::Builder::initBaselineRevision(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void AutomaticRuntimeProfile::ReplayValidation::Builder::adoptBaselineRevision(
    ::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> AutomaticRuntimeProfile::ReplayValidation::Builder::disownBaselineRevision() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline bool AutomaticRuntimeProfile::ReplayValidation::Reader::hasPhysicalModelRevision() const {
  return !_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline bool AutomaticRuntimeProfile::ReplayValidation::Builder::hasPhysicalModelRevision() {
  return !_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader AutomaticRuntimeProfile::ReplayValidation::Reader::getPhysicalModelRevision() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder AutomaticRuntimeProfile::ReplayValidation::Builder::getPhysicalModelRevision() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline void AutomaticRuntimeProfile::ReplayValidation::Builder::setPhysicalModelRevision( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder AutomaticRuntimeProfile::ReplayValidation::Builder::initPhysicalModelRevision(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), size);
}
inline void AutomaticRuntimeProfile::ReplayValidation::Builder::adoptPhysicalModelRevision(
    ::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> AutomaticRuntimeProfile::ReplayValidation::Builder::disownPhysicalModelRevision() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}

inline bool AutomaticRuntimeProfile::ReplayValidation::Reader::getNoSaturationRegression() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline bool AutomaticRuntimeProfile::ReplayValidation::Builder::getNoSaturationRegression() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void AutomaticRuntimeProfile::ReplayValidation::Builder::setNoSaturationRegression(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool AutomaticRuntimeProfile::ReplayValidation::Reader::getNoSlewRegression() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline bool AutomaticRuntimeProfile::ReplayValidation::Builder::getNoSlewRegression() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void AutomaticRuntimeProfile::ReplayValidation::Builder::setNoSlewRegression(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline double AutomaticRuntimeProfile::ReplayValidation::Reader::getWorstCohortImprovement() const {
  return _reader.getDataField<double>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline double AutomaticRuntimeProfile::ReplayValidation::Builder::getWorstCohortImprovement() {
  return _builder.getDataField<double>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void AutomaticRuntimeProfile::ReplayValidation::Builder::setWorstCohortImprovement(double value) {
  _builder.setDataField<double>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline bool AutomaticRuntimeProfile::ReplayValidation::Reader::hasNativeBaselineValues() const {
  return !_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline bool AutomaticRuntimeProfile::ReplayValidation::Builder::hasNativeBaselineValues() {
  return !_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Reader AutomaticRuntimeProfile::ReplayValidation::Reader::getNativeBaselineValues() const {
  return ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Builder AutomaticRuntimeProfile::ReplayValidation::Builder::getNativeBaselineValues() {
  return ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline void AutomaticRuntimeProfile::ReplayValidation::Builder::setNativeBaselineValues( ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), value);
}
inline void AutomaticRuntimeProfile::ReplayValidation::Builder::setNativeBaselineValues(::kj::ArrayPtr<const double> value) {
  ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), value);
}
inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Builder AutomaticRuntimeProfile::ReplayValidation::Builder::initNativeBaselineValues(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), size);
}
inline void AutomaticRuntimeProfile::ReplayValidation::Builder::adoptNativeBaselineValues(
    ::capnp::Orphan< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>> AutomaticRuntimeProfile::ReplayValidation::Builder::disownNativeBaselineValues() {
  return ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}

inline bool AutomaticRuntimeProfile::Parameter::Reader::hasName() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool AutomaticRuntimeProfile::Parameter::Builder::hasName() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader AutomaticRuntimeProfile::Parameter::Reader::getName() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder AutomaticRuntimeProfile::Parameter::Builder::getName() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void AutomaticRuntimeProfile::Parameter::Builder::setName( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder AutomaticRuntimeProfile::Parameter::Builder::initName(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void AutomaticRuntimeProfile::Parameter::Builder::adoptName(
    ::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> AutomaticRuntimeProfile::Parameter::Builder::disownName() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline bool AutomaticRuntimeProfile::Parameter::Reader::hasStageRevision() const {
  return !_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline bool AutomaticRuntimeProfile::Parameter::Builder::hasStageRevision() {
  return !_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader AutomaticRuntimeProfile::Parameter::Reader::getStageRevision() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder AutomaticRuntimeProfile::Parameter::Builder::getStageRevision() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline void AutomaticRuntimeProfile::Parameter::Builder::setStageRevision( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder AutomaticRuntimeProfile::Parameter::Builder::initStageRevision(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), size);
}
inline void AutomaticRuntimeProfile::Parameter::Builder::adoptStageRevision(
    ::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> AutomaticRuntimeProfile::Parameter::Builder::disownStageRevision() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}

inline double AutomaticRuntimeProfile::Parameter::Reader::getLow() const {
  return _reader.getDataField<double>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline double AutomaticRuntimeProfile::Parameter::Builder::getLow() {
  return _builder.getDataField<double>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void AutomaticRuntimeProfile::Parameter::Builder::setLow(double value) {
  _builder.setDataField<double>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline double AutomaticRuntimeProfile::Parameter::Reader::getHigh() const {
  return _reader.getDataField<double>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline double AutomaticRuntimeProfile::Parameter::Builder::getHigh() {
  return _builder.getDataField<double>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void AutomaticRuntimeProfile::Parameter::Builder::setHigh(double value) {
  _builder.setDataField<double>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline double AutomaticRuntimeProfile::Parameter::Reader::getMaxStep() const {
  return _reader.getDataField<double>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline double AutomaticRuntimeProfile::Parameter::Builder::getMaxStep() {
  return _builder.getDataField<double>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void AutomaticRuntimeProfile::Parameter::Builder::setMaxStep(double value) {
  _builder.setDataField<double>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline double AutomaticRuntimeProfile::Parameter::Reader::getSlewPerS() const {
  return _reader.getDataField<double>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}

inline double AutomaticRuntimeProfile::Parameter::Builder::getSlewPerS() {
  return _builder.getDataField<double>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}
inline void AutomaticRuntimeProfile::Parameter::Builder::setSlewPerS(double value) {
  _builder.setDataField<double>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS, value);
}

inline double AutomaticRuntimeProfile::Parameter::Reader::getExcitationFloor() const {
  return _reader.getDataField<double>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS, 4576918229304087675ull);
}

inline double AutomaticRuntimeProfile::Parameter::Builder::getExcitationFloor() {
  return _builder.getDataField<double>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS, 4576918229304087675ull);
}
inline void AutomaticRuntimeProfile::Parameter::Builder::setExcitationFloor(double value) {
  _builder.setDataField<double>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS, value, 4576918229304087675ull);
}

inline bool AutomaticRuntimeProfile::CohortImprovement::Reader::hasName() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool AutomaticRuntimeProfile::CohortImprovement::Builder::hasName() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader AutomaticRuntimeProfile::CohortImprovement::Reader::getName() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder AutomaticRuntimeProfile::CohortImprovement::Builder::getName() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void AutomaticRuntimeProfile::CohortImprovement::Builder::setName( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder AutomaticRuntimeProfile::CohortImprovement::Builder::initName(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void AutomaticRuntimeProfile::CohortImprovement::Builder::adoptName(
    ::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> AutomaticRuntimeProfile::CohortImprovement::Builder::disownName() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline double AutomaticRuntimeProfile::CohortImprovement::Reader::getLowerBound() const {
  return _reader.getDataField<double>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline double AutomaticRuntimeProfile::CohortImprovement::Builder::getLowerBound() {
  return _builder.getDataField<double>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void AutomaticRuntimeProfile::CohortImprovement::Builder::setLowerBound(double value) {
  _builder.setDataField<double>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline  ::uint16_t AutomaticLearningSourceReceipt::Reader::getVersion() const {
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline  ::uint16_t AutomaticLearningSourceReceipt::Builder::getVersion() {
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void AutomaticLearningSourceReceipt::Builder::setVersion( ::uint16_t value) {
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool AutomaticLearningSourceReceipt::Reader::getEnabled() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS);
}

inline bool AutomaticLearningSourceReceipt::Builder::getEnabled() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS);
}
inline void AutomaticLearningSourceReceipt::Builder::setEnabled(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS, value);
}

inline bool AutomaticLearningSourceReceipt::Reader::getManual() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<17>() * ::capnp::ELEMENTS);
}

inline bool AutomaticLearningSourceReceipt::Builder::getManual() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<17>() * ::capnp::ELEMENTS);
}
inline void AutomaticLearningSourceReceipt::Builder::setManual(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<17>() * ::capnp::ELEMENTS, value);
}

inline bool AutomaticLearningSourceReceipt::Reader::hasResetGeneration() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool AutomaticLearningSourceReceipt::Builder::hasResetGeneration() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader AutomaticLearningSourceReceipt::Reader::getResetGeneration() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder AutomaticLearningSourceReceipt::Builder::getResetGeneration() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void AutomaticLearningSourceReceipt::Builder::setResetGeneration( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder AutomaticLearningSourceReceipt::Builder::initResetGeneration(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void AutomaticLearningSourceReceipt::Builder::adoptResetGeneration(
    ::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> AutomaticLearningSourceReceipt::Builder::disownResetGeneration() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline bool AutomaticLearningSourceReceipt::Reader::hasSourceEpoch() const {
  return !_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline bool AutomaticLearningSourceReceipt::Builder::hasSourceEpoch() {
  return !_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader AutomaticLearningSourceReceipt::Reader::getSourceEpoch() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder AutomaticLearningSourceReceipt::Builder::getSourceEpoch() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline void AutomaticLearningSourceReceipt::Builder::setSourceEpoch( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder AutomaticLearningSourceReceipt::Builder::initSourceEpoch(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), size);
}
inline void AutomaticLearningSourceReceipt::Builder::adoptSourceEpoch(
    ::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> AutomaticLearningSourceReceipt::Builder::disownSourceEpoch() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}

inline  ::uint64_t AutomaticLearningSourceReceipt::Reader::getObservedMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t AutomaticLearningSourceReceipt::Builder::getObservedMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void AutomaticLearningSourceReceipt::Builder::setObservedMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t AutomaticLearningSourceReceipt::Reader::getValidUntilMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t AutomaticLearningSourceReceipt::Builder::getValidUntilMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void AutomaticLearningSourceReceipt::Builder::setValidUntilMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline bool AutomaticLearningSourceReceipt::Reader::hasCpSha256() const {
  return !_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline bool AutomaticLearningSourceReceipt::Builder::hasCpSha256() {
  return !_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader AutomaticLearningSourceReceipt::Reader::getCpSha256() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder AutomaticLearningSourceReceipt::Builder::getCpSha256() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline void AutomaticLearningSourceReceipt::Builder::setCpSha256( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder AutomaticLearningSourceReceipt::Builder::initCpSha256(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), size);
}
inline void AutomaticLearningSourceReceipt::Builder::adoptCpSha256(
    ::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> AutomaticLearningSourceReceipt::Builder::disownCpSha256() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}

inline bool AutomaticLearningSourceReceipt::Reader::hasCalibrationBasis() const {
  return !_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline bool AutomaticLearningSourceReceipt::Builder::hasCalibrationBasis() {
  return !_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Reader AutomaticLearningSourceReceipt::Reader::getCalibrationBasis() const {
  return ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Builder AutomaticLearningSourceReceipt::Builder::getCalibrationBasis() {
  return ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline void AutomaticLearningSourceReceipt::Builder::setCalibrationBasis( ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), value);
}
inline void AutomaticLearningSourceReceipt::Builder::setCalibrationBasis(::kj::ArrayPtr<const double> value) {
  ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), value);
}
inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Builder AutomaticLearningSourceReceipt::Builder::initCalibrationBasis(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), size);
}
inline void AutomaticLearningSourceReceipt::Builder::adoptCalibrationBasis(
    ::capnp::Orphan< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>> AutomaticLearningSourceReceipt::Builder::disownCalibrationBasis() {
  return ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}

inline bool AutomaticLearningSourceReceipt::Reader::hasCalibrationGeneration() const {
  return !_reader.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS).isNull();
}
inline bool AutomaticLearningSourceReceipt::Builder::hasCalibrationGeneration() {
  return !_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader AutomaticLearningSourceReceipt::Reader::getCalibrationGeneration() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder AutomaticLearningSourceReceipt::Builder::getCalibrationGeneration() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}
inline void AutomaticLearningSourceReceipt::Builder::setCalibrationGeneration( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder AutomaticLearningSourceReceipt::Builder::initCalibrationGeneration(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), size);
}
inline void AutomaticLearningSourceReceipt::Builder::adoptCalibrationGeneration(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> AutomaticLearningSourceReceipt::Builder::disownCalibrationGeneration() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}

inline bool AutomaticLearningSourceReceipt::Reader::hasPersistentSourceEpoch() const {
  return !_reader.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS).isNull();
}
inline bool AutomaticLearningSourceReceipt::Builder::hasPersistentSourceEpoch() {
  return !_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader AutomaticLearningSourceReceipt::Reader::getPersistentSourceEpoch() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder AutomaticLearningSourceReceipt::Builder::getPersistentSourceEpoch() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS));
}
inline void AutomaticLearningSourceReceipt::Builder::setPersistentSourceEpoch( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder AutomaticLearningSourceReceipt::Builder::initPersistentSourceEpoch(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS), size);
}
inline void AutomaticLearningSourceReceipt::Builder::adoptPersistentSourceEpoch(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> AutomaticLearningSourceReceipt::Builder::disownPersistentSourceEpoch() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS));
}

inline  ::uint16_t LearningApplication::Reader::getVersion() const {
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline  ::uint16_t LearningApplication::Builder::getVersion() {
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void LearningApplication::Builder::setVersion( ::uint16_t value) {
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool LearningApplication::Reader::hasIdentity() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool LearningApplication::Builder::hasIdentity() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader LearningApplication::Reader::getIdentity() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder LearningApplication::Builder::getIdentity() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void LearningApplication::Builder::setIdentity( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder LearningApplication::Builder::initIdentity(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void LearningApplication::Builder::adoptIdentity(
    ::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> LearningApplication::Builder::disownIdentity() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline  ::uint64_t LearningApplication::Reader::getProfileSequence() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t LearningApplication::Builder::getProfileSequence() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void LearningApplication::Builder::setProfileSequence( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t LearningApplication::Reader::getObservedMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t LearningApplication::Builder::getObservedMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void LearningApplication::Builder::setObservedMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline bool LearningApplication::Reader::hasStatus() const {
  return !_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline bool LearningApplication::Builder::hasStatus() {
  return !_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader LearningApplication::Reader::getStatus() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder LearningApplication::Builder::getStatus() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline void LearningApplication::Builder::setStatus( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder LearningApplication::Builder::initStatus(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), size);
}
inline void LearningApplication::Builder::adoptStatus(
    ::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> LearningApplication::Builder::disownStatus() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}

inline bool LearningApplication::Reader::hasActualCoordinates() const {
  return !_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline bool LearningApplication::Builder::hasActualCoordinates() {
  return !_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Reader LearningApplication::Reader::getActualCoordinates() const {
  return ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Builder LearningApplication::Builder::getActualCoordinates() {
  return ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline void LearningApplication::Builder::setActualCoordinates( ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), value);
}
inline void LearningApplication::Builder::setActualCoordinates(::kj::ArrayPtr<const double> value) {
  ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), value);
}
inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Builder LearningApplication::Builder::initActualCoordinates(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), size);
}
inline void LearningApplication::Builder::adoptActualCoordinates(
    ::capnp::Orphan< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>> LearningApplication::Builder::disownActualCoordinates() {
  return ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}

inline bool LearningApplication::Reader::hasReason() const {
  return !_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline bool LearningApplication::Builder::hasReason() {
  return !_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader LearningApplication::Reader::getReason() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder LearningApplication::Builder::getReason() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline void LearningApplication::Builder::setReason( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder LearningApplication::Builder::initReason(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), size);
}
inline void LearningApplication::Builder::adoptReason(
    ::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> LearningApplication::Builder::disownReason() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}

inline bool LearningApplication::Reader::hasBaselineRevision() const {
  return !_reader.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS).isNull();
}
inline bool LearningApplication::Builder::hasBaselineRevision() {
  return !_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader LearningApplication::Reader::getBaselineRevision() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder LearningApplication::Builder::getBaselineRevision() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}
inline void LearningApplication::Builder::setBaselineRevision( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder LearningApplication::Builder::initBaselineRevision(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), size);
}
inline void LearningApplication::Builder::adoptBaselineRevision(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> LearningApplication::Builder::disownBaselineRevision() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}

inline bool LearningApplication::Reader::hasPhysicalModelRevision() const {
  return !_reader.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS).isNull();
}
inline bool LearningApplication::Builder::hasPhysicalModelRevision() {
  return !_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader LearningApplication::Reader::getPhysicalModelRevision() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder LearningApplication::Builder::getPhysicalModelRevision() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS));
}
inline void LearningApplication::Builder::setPhysicalModelRevision( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder LearningApplication::Builder::initPhysicalModelRevision(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS), size);
}
inline void LearningApplication::Builder::adoptPhysicalModelRevision(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> LearningApplication::Builder::disownPhysicalModelRevision() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS));
}

inline bool LearningApplication::Reader::hasEffectManifestSha256() const {
  return !_reader.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS).isNull();
}
inline bool LearningApplication::Builder::hasEffectManifestSha256() {
  return !_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader LearningApplication::Reader::getEffectManifestSha256() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder LearningApplication::Builder::getEffectManifestSha256() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS));
}
inline void LearningApplication::Builder::setEffectManifestSha256( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder LearningApplication::Builder::initEffectManifestSha256(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS), size);
}
inline void LearningApplication::Builder::adoptEffectManifestSha256(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> LearningApplication::Builder::disownEffectManifestSha256() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS));
}

inline bool LearningApplication::Reader::hasEffectOriginalAnchor() const {
  return !_reader.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS).isNull();
}
inline bool LearningApplication::Builder::hasEffectOriginalAnchor() {
  return !_builder.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader LearningApplication::Reader::getEffectOriginalAnchor() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder LearningApplication::Builder::getEffectOriginalAnchor() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS));
}
inline void LearningApplication::Builder::setEffectOriginalAnchor( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder LearningApplication::Builder::initEffectOriginalAnchor(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS), size);
}
inline void LearningApplication::Builder::adoptEffectOriginalAnchor(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> LearningApplication::Builder::disownEffectOriginalAnchor() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS));
}

inline bool LearningApplication::Reader::hasEffectAppliedProfileSha256() const {
  return !_reader.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS).isNull();
}
inline bool LearningApplication::Builder::hasEffectAppliedProfileSha256() {
  return !_builder.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader LearningApplication::Reader::getEffectAppliedProfileSha256() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder LearningApplication::Builder::getEffectAppliedProfileSha256() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS));
}
inline void LearningApplication::Builder::setEffectAppliedProfileSha256( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder LearningApplication::Builder::initEffectAppliedProfileSha256(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS), size);
}
inline void LearningApplication::Builder::adoptEffectAppliedProfileSha256(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> LearningApplication::Builder::disownEffectAppliedProfileSha256() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS));
}

inline  ::uint16_t FordLearningEvidence::Reader::getVersion() const {
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline  ::uint16_t FordLearningEvidence::Builder::getVersion() {
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void FordLearningEvidence::Builder::setVersion( ::uint16_t value) {
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool FordLearningEvidence::Reader::hasIdentity() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool FordLearningEvidence::Builder::hasIdentity() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader FordLearningEvidence::Reader::getIdentity() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder FordLearningEvidence::Builder::getIdentity() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void FordLearningEvidence::Builder::setIdentity( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder FordLearningEvidence::Builder::initIdentity(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void FordLearningEvidence::Builder::adoptIdentity(
    ::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> FordLearningEvidence::Builder::disownIdentity() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline  ::uint64_t FordLearningEvidence::Reader::getGeneration() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t FordLearningEvidence::Builder::getGeneration() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void FordLearningEvidence::Builder::setGeneration( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline bool FordLearningEvidence::Reader::hasSourceEpoch() const {
  return !_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline bool FordLearningEvidence::Builder::hasSourceEpoch() {
  return !_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader FordLearningEvidence::Reader::getSourceEpoch() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder FordLearningEvidence::Builder::getSourceEpoch() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline void FordLearningEvidence::Builder::setSourceEpoch( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder FordLearningEvidence::Builder::initSourceEpoch(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), size);
}
inline void FordLearningEvidence::Builder::adoptSourceEpoch(
    ::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> FordLearningEvidence::Builder::disownSourceEpoch() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}

inline bool FordLearningEvidence::Reader::hasBaselineRevision() const {
  return !_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline bool FordLearningEvidence::Builder::hasBaselineRevision() {
  return !_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader FordLearningEvidence::Reader::getBaselineRevision() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder FordLearningEvidence::Builder::getBaselineRevision() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline void FordLearningEvidence::Builder::setBaselineRevision( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder FordLearningEvidence::Builder::initBaselineRevision(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), size);
}
inline void FordLearningEvidence::Builder::adoptBaselineRevision(
    ::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> FordLearningEvidence::Builder::disownBaselineRevision() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}

inline bool FordLearningEvidence::Reader::hasBaselineValues() const {
  return !_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline bool FordLearningEvidence::Builder::hasBaselineValues() {
  return !_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Reader FordLearningEvidence::Reader::getBaselineValues() const {
  return ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Builder FordLearningEvidence::Builder::getBaselineValues() {
  return ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline void FordLearningEvidence::Builder::setBaselineValues( ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), value);
}
inline void FordLearningEvidence::Builder::setBaselineValues(::kj::ArrayPtr<const double> value) {
  ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), value);
}
inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Builder FordLearningEvidence::Builder::initBaselineValues(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), size);
}
inline void FordLearningEvidence::Builder::adoptBaselineValues(
    ::capnp::Orphan< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>> FordLearningEvidence::Builder::disownBaselineValues() {
  return ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}

inline bool FordLearningEvidence::Reader::hasControllerRevision() const {
  return !_reader.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS).isNull();
}
inline bool FordLearningEvidence::Builder::hasControllerRevision() {
  return !_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader FordLearningEvidence::Reader::getControllerRevision() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder FordLearningEvidence::Builder::getControllerRevision() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}
inline void FordLearningEvidence::Builder::setControllerRevision( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder FordLearningEvidence::Builder::initControllerRevision(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), size);
}
inline void FordLearningEvidence::Builder::adoptControllerRevision(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> FordLearningEvidence::Builder::disownControllerRevision() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}

inline bool FordLearningEvidence::Reader::hasCpSha256() const {
  return !_reader.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS).isNull();
}
inline bool FordLearningEvidence::Builder::hasCpSha256() {
  return !_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader FordLearningEvidence::Reader::getCpSha256() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder FordLearningEvidence::Builder::getCpSha256() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS));
}
inline void FordLearningEvidence::Builder::setCpSha256( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder FordLearningEvidence::Builder::initCpSha256(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS), size);
}
inline void FordLearningEvidence::Builder::adoptCpSha256(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> FordLearningEvidence::Builder::disownCpSha256() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS));
}

inline bool FordLearningEvidence::Reader::hasControllerMode() const {
  return !_reader.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS).isNull();
}
inline bool FordLearningEvidence::Builder::hasControllerMode() {
  return !_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader FordLearningEvidence::Reader::getControllerMode() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder FordLearningEvidence::Builder::getControllerMode() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS));
}
inline void FordLearningEvidence::Builder::setControllerMode( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder FordLearningEvidence::Builder::initControllerMode(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS), size);
}
inline void FordLearningEvidence::Builder::adoptControllerMode(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> FordLearningEvidence::Builder::disownControllerMode() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS));
}

inline bool FordLearningEvidence::Reader::hasPolicy() const {
  return !_reader.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS).isNull();
}
inline bool FordLearningEvidence::Builder::hasPolicy() {
  return !_builder.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader FordLearningEvidence::Reader::getPolicy() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder FordLearningEvidence::Builder::getPolicy() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS));
}
inline void FordLearningEvidence::Builder::setPolicy( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder FordLearningEvidence::Builder::initPolicy(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS), size);
}
inline void FordLearningEvidence::Builder::adoptPolicy(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> FordLearningEvidence::Builder::disownPolicy() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS));
}

inline bool FordLearningEvidence::Reader::hasConversionRevision() const {
  return !_reader.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS).isNull();
}
inline bool FordLearningEvidence::Builder::hasConversionRevision() {
  return !_builder.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader FordLearningEvidence::Reader::getConversionRevision() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder FordLearningEvidence::Builder::getConversionRevision() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS));
}
inline void FordLearningEvidence::Builder::setConversionRevision( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder FordLearningEvidence::Builder::initConversionRevision(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS), size);
}
inline void FordLearningEvidence::Builder::adoptConversionRevision(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> FordLearningEvidence::Builder::disownConversionRevision() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS));
}

inline bool FordLearningEvidence::Reader::hasStageRevision() const {
  return !_reader.getPointerField(
      ::capnp::bounded<9>() * ::capnp::POINTERS).isNull();
}
inline bool FordLearningEvidence::Builder::hasStageRevision() {
  return !_builder.getPointerField(
      ::capnp::bounded<9>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader FordLearningEvidence::Reader::getStageRevision() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<9>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder FordLearningEvidence::Builder::getStageRevision() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<9>() * ::capnp::POINTERS));
}
inline void FordLearningEvidence::Builder::setStageRevision( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<9>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder FordLearningEvidence::Builder::initStageRevision(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<9>() * ::capnp::POINTERS), size);
}
inline void FordLearningEvidence::Builder::adoptStageRevision(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<9>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> FordLearningEvidence::Builder::disownStageRevision() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<9>() * ::capnp::POINTERS));
}

inline  ::uint64_t FordLearningEvidence::Reader::getSourceReceiptMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t FordLearningEvidence::Builder::getSourceReceiptMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void FordLearningEvidence::Builder::setSourceReceiptMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t FordLearningEvidence::Reader::getSourceValidUntilMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t FordLearningEvidence::Builder::getSourceValidUntilMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}
inline void FordLearningEvidence::Builder::setSourceValidUntilMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS, value);
}

inline bool FordLearningEvidence::Reader::getEnabled() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS);
}

inline bool FordLearningEvidence::Builder::getEnabled() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS);
}
inline void FordLearningEvidence::Builder::setEnabled(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS, value);
}

inline bool FordLearningEvidence::Reader::getManual() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<17>() * ::capnp::ELEMENTS);
}

inline bool FordLearningEvidence::Builder::getManual() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<17>() * ::capnp::ELEMENTS);
}
inline void FordLearningEvidence::Builder::setManual(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<17>() * ::capnp::ELEMENTS, value);
}

inline bool FordLearningEvidence::Reader::hasRows() const {
  return !_reader.getPointerField(
      ::capnp::bounded<10>() * ::capnp::POINTERS).isNull();
}
inline bool FordLearningEvidence::Builder::hasRows() {
  return !_builder.getPointerField(
      ::capnp::bounded<10>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::List< ::cereal::FordLearningEvent,  ::capnp::Kind::STRUCT>::Reader FordLearningEvidence::Reader::getRows() const {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::FordLearningEvent,  ::capnp::Kind::STRUCT>>::get(_reader.getPointerField(
      ::capnp::bounded<10>() * ::capnp::POINTERS));
}
inline  ::capnp::List< ::cereal::FordLearningEvent,  ::capnp::Kind::STRUCT>::Builder FordLearningEvidence::Builder::getRows() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::FordLearningEvent,  ::capnp::Kind::STRUCT>>::get(_builder.getPointerField(
      ::capnp::bounded<10>() * ::capnp::POINTERS));
}
inline void FordLearningEvidence::Builder::setRows( ::capnp::List< ::cereal::FordLearningEvent,  ::capnp::Kind::STRUCT>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::FordLearningEvent,  ::capnp::Kind::STRUCT>>::set(_builder.getPointerField(
      ::capnp::bounded<10>() * ::capnp::POINTERS), value);
}
inline  ::capnp::List< ::cereal::FordLearningEvent,  ::capnp::Kind::STRUCT>::Builder FordLearningEvidence::Builder::initRows(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::FordLearningEvent,  ::capnp::Kind::STRUCT>>::init(_builder.getPointerField(
      ::capnp::bounded<10>() * ::capnp::POINTERS), size);
}
inline void FordLearningEvidence::Builder::adoptRows(
    ::capnp::Orphan< ::capnp::List< ::cereal::FordLearningEvent,  ::capnp::Kind::STRUCT>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::FordLearningEvent,  ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField(
      ::capnp::bounded<10>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List< ::cereal::FordLearningEvent,  ::capnp::Kind::STRUCT>> FordLearningEvidence::Builder::disownRows() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::FordLearningEvent,  ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField(
      ::capnp::bounded<10>() * ::capnp::POINTERS));
}

inline  ::uint64_t FordLearningEvidence::Reader::getDropped() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t FordLearningEvidence::Builder::getDropped() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}
inline void FordLearningEvidence::Builder::setDropped( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t FordLearningEvidence::Reader::getAppliedProfileSequence() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t FordLearningEvidence::Builder::getAppliedProfileSequence() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}
inline void FordLearningEvidence::Builder::setAppliedProfileSequence( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t FordLearningEvidence::Reader::getAppliedProfileObservedMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t FordLearningEvidence::Builder::getAppliedProfileObservedMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS);
}
inline void FordLearningEvidence::Builder::setAppliedProfileObservedMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t FordLearningEvidence::Reader::getAppliedProfileValidUntilMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<7>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t FordLearningEvidence::Builder::getAppliedProfileValidUntilMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<7>() * ::capnp::ELEMENTS);
}
inline void FordLearningEvidence::Builder::setAppliedProfileValidUntilMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<7>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t FordLearningEvent::Reader::getEventMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t FordLearningEvent::Builder::getEventMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void FordLearningEvent::Builder::setEventMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t FordLearningEvent::Reader::getSequence() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t FordLearningEvent::Builder::getSequence() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void FordLearningEvent::Builder::setSequence( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline bool FordLearningEvent::Reader::hasKind() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool FordLearningEvent::Builder::hasKind() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader FordLearningEvent::Reader::getKind() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder FordLearningEvent::Builder::getKind() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void FordLearningEvent::Builder::setKind( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder FordLearningEvent::Builder::initKind(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void FordLearningEvent::Builder::adoptKind(
    ::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> FordLearningEvent::Builder::disownKind() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline bool FordLearningEvent::Reader::hasInputs() const {
  return !_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline bool FordLearningEvent::Builder::hasInputs() {
  return !_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>::Reader FordLearningEvent::Reader::getInputs() const {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>>::get(_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline  ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>::Builder FordLearningEvent::Builder::getInputs() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>>::get(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline void FordLearningEvent::Builder::setInputs( ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>>::set(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), value);
}
inline  ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>::Builder FordLearningEvent::Builder::initInputs(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>>::init(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), size);
}
inline void FordLearningEvent::Builder::adoptInputs(
    ::capnp::Orphan< ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>> FordLearningEvent::Builder::disownInputs() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}

inline double FordLearningEvent::Reader::getAppliedCoefficient() const {
  return _reader.getDataField<double>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline double FordLearningEvent::Builder::getAppliedCoefficient() {
  return _builder.getDataField<double>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void FordLearningEvent::Builder::setAppliedCoefficient(double value) {
  _builder.setDataField<double>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline bool FordLearningEvent::Reader::hasActualPending() const {
  return !_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline bool FordLearningEvent::Builder::hasActualPending() {
  return !_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Reader FordLearningEvent::Reader::getActualPending() const {
  return ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Builder FordLearningEvent::Builder::getActualPending() {
  return ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline void FordLearningEvent::Builder::setActualPending( ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), value);
}
inline void FordLearningEvent::Builder::setActualPending(::kj::ArrayPtr<const double> value) {
  ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), value);
}
inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Builder FordLearningEvent::Builder::initActualPending(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), size);
}
inline void FordLearningEvent::Builder::adoptActualPending(
    ::capnp::Orphan< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>> FordLearningEvent::Builder::disownActualPending() {
  return ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}

inline bool FordLearningEvent::Reader::hasActualCommand() const {
  return !_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline bool FordLearningEvent::Builder::hasActualCommand() {
  return !_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Reader FordLearningEvent::Reader::getActualCommand() const {
  return ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Builder FordLearningEvent::Builder::getActualCommand() {
  return ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline void FordLearningEvent::Builder::setActualCommand( ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), value);
}
inline void FordLearningEvent::Builder::setActualCommand(::kj::ArrayPtr<const double> value) {
  ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), value);
}
inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Builder FordLearningEvent::Builder::initActualCommand(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), size);
}
inline void FordLearningEvent::Builder::adoptActualCommand(
    ::capnp::Orphan< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>> FordLearningEvent::Builder::disownActualCommand() {
  return ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}

inline  ::uint64_t FordLearningEvent::Reader::getControlMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t FordLearningEvent::Builder::getControlMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}
inline void FordLearningEvent::Builder::setControlMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t FordLearningEvent::Reader::getPendingControlMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t FordLearningEvent::Builder::getPendingControlMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}
inline void FordLearningEvent::Builder::setPendingControlMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t FordLearningEvent::Reader::getAnnouncedControlMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t FordLearningEvent::Builder::getAnnouncedControlMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}
inline void FordLearningEvent::Builder::setAnnouncedControlMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t FordLearningEvent::Reader::getCarStateMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t FordLearningEvent::Builder::getCarStateMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS);
}
inline void FordLearningEvent::Builder::setCarStateMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS, value);
}

inline bool FordLearningEvent::Reader::getNativeAllowed() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<448>() * ::capnp::ELEMENTS);
}

inline bool FordLearningEvent::Builder::getNativeAllowed() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<448>() * ::capnp::ELEMENTS);
}
inline void FordLearningEvent::Builder::setNativeAllowed(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<448>() * ::capnp::ELEMENTS, value);
}

inline bool FordLearningEvent::Reader::getFault() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<449>() * ::capnp::ELEMENTS);
}

inline bool FordLearningEvent::Builder::getFault() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<449>() * ::capnp::ELEMENTS);
}
inline void FordLearningEvent::Builder::setFault(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<449>() * ::capnp::ELEMENTS, value);
}

inline bool FordLearningEvent::Reader::getOverride() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<450>() * ::capnp::ELEMENTS);
}

inline bool FordLearningEvent::Builder::getOverride() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<450>() * ::capnp::ELEMENTS);
}
inline void FordLearningEvent::Builder::setOverride(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<450>() * ::capnp::ELEMENTS, value);
}

inline bool FordLearningEvent::Reader::getLimited() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<451>() * ::capnp::ELEMENTS);
}

inline bool FordLearningEvent::Builder::getLimited() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<451>() * ::capnp::ELEMENTS);
}
inline void FordLearningEvent::Builder::setLimited(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<451>() * ::capnp::ELEMENTS, value);
}

inline bool FordLearningEvent::Reader::getHasWirePath() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<452>() * ::capnp::ELEMENTS);
}

inline bool FordLearningEvent::Builder::getHasWirePath() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<452>() * ::capnp::ELEMENTS);
}
inline void FordLearningEvent::Builder::setHasWirePath(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<452>() * ::capnp::ELEMENTS, value);
}

inline double FordLearningEvent::Reader::getActualWirePath() const {
  return _reader.getDataField<double>(
      ::capnp::bounded<8>() * ::capnp::ELEMENTS);
}

inline double FordLearningEvent::Builder::getActualWirePath() {
  return _builder.getDataField<double>(
      ::capnp::bounded<8>() * ::capnp::ELEMENTS);
}
inline void FordLearningEvent::Builder::setActualWirePath(double value) {
  _builder.setDataField<double>(
      ::capnp::bounded<8>() * ::capnp::ELEMENTS, value);
}

inline bool FordLearningEvent::Reader::hasCheckpoint() const {
  return !_reader.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS).isNull();
}
inline bool FordLearningEvent::Builder::hasCheckpoint() {
  return !_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>::Reader FordLearningEvent::Reader::getCheckpoint() const {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>>::get(_reader.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}
inline  ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>::Builder FordLearningEvent::Builder::getCheckpoint() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>>::get(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}
inline void FordLearningEvent::Builder::setCheckpoint( ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>>::set(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), value);
}
inline  ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>::Builder FordLearningEvent::Builder::initCheckpoint(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>>::init(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), size);
}
inline void FordLearningEvent::Builder::adoptCheckpoint(
    ::capnp::Orphan< ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>> FordLearningEvent::Builder::disownCheckpoint() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}

inline  ::uint64_t FordLearningEvent::Reader::getCheckpointSequence() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<9>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t FordLearningEvent::Builder::getCheckpointSequence() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<9>() * ::capnp::ELEMENTS);
}
inline void FordLearningEvent::Builder::setCheckpointSequence( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<9>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t FordLearningEvent::Reader::getSourceReceiptMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<10>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t FordLearningEvent::Builder::getSourceReceiptMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<10>() * ::capnp::ELEMENTS);
}
inline void FordLearningEvent::Builder::setSourceReceiptMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<10>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t FordLearningEvent::Reader::getSourceValidUntilMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<11>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t FordLearningEvent::Builder::getSourceValidUntilMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<11>() * ::capnp::ELEMENTS);
}
inline void FordLearningEvent::Builder::setSourceValidUntilMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<11>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t FordLearningEvent::Reader::getAppliedProfileSequence() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<12>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t FordLearningEvent::Builder::getAppliedProfileSequence() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<12>() * ::capnp::ELEMENTS);
}
inline void FordLearningEvent::Builder::setAppliedProfileSequence( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<12>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t FordLearningEvent::Reader::getAppliedProfileObservedMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<13>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t FordLearningEvent::Builder::getAppliedProfileObservedMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<13>() * ::capnp::ELEMENTS);
}
inline void FordLearningEvent::Builder::setAppliedProfileObservedMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<13>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t FordLearningEvent::Reader::getAppliedProfileValidUntilMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<14>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t FordLearningEvent::Builder::getAppliedProfileValidUntilMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<14>() * ::capnp::ELEMENTS);
}
inline void FordLearningEvent::Builder::setAppliedProfileValidUntilMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<14>() * ::capnp::ELEMENTS, value);
}

inline bool FordLearningEvent::Reader::hasNativeIdentity() const {
  return !_reader.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS).isNull();
}
inline bool FordLearningEvent::Builder::hasNativeIdentity() {
  return !_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader FordLearningEvent::Reader::getNativeIdentity() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder FordLearningEvent::Builder::getNativeIdentity() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS));
}
inline void FordLearningEvent::Builder::setNativeIdentity( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder FordLearningEvent::Builder::initNativeIdentity(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS), size);
}
inline void FordLearningEvent::Builder::adoptNativeIdentity(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> FordLearningEvent::Builder::disownNativeIdentity() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS));
}

inline  ::uint64_t FordLearningEvent::Reader::getNativeObservedMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<15>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t FordLearningEvent::Builder::getNativeObservedMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<15>() * ::capnp::ELEMENTS);
}
inline void FordLearningEvent::Builder::setNativeObservedMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<15>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t FordLearningEvent::Reader::getNativeValidUntilMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t FordLearningEvent::Builder::getNativeValidUntilMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS);
}
inline void FordLearningEvent::Builder::setNativeValidUntilMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t FordLearningEvent::Reader::getNativeValidatedMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<17>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t FordLearningEvent::Builder::getNativeValidatedMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<17>() * ::capnp::ELEMENTS);
}
inline void FordLearningEvent::Builder::setNativeValidatedMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<17>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t FordLearningEvent::Reader::getNativeCommandMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<18>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t FordLearningEvent::Builder::getNativeCommandMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<18>() * ::capnp::ELEMENTS);
}
inline void FordLearningEvent::Builder::setNativeCommandMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<18>() * ::capnp::ELEMENTS, value);
}

inline double FordLearningEvent::Reader::getAnnouncedCoefficient() const {
  return _reader.getDataField<double>(
      ::capnp::bounded<19>() * ::capnp::ELEMENTS);
}

inline double FordLearningEvent::Builder::getAnnouncedCoefficient() {
  return _builder.getDataField<double>(
      ::capnp::bounded<19>() * ::capnp::ELEMENTS);
}
inline void FordLearningEvent::Builder::setAnnouncedCoefficient(double value) {
  _builder.setDataField<double>(
      ::capnp::bounded<19>() * ::capnp::ELEMENTS, value);
}

inline  ::uint16_t CentreApplicationWitness::Reader::getVersion() const {
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline  ::uint16_t CentreApplicationWitness::Builder::getVersion() {
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void CentreApplicationWitness::Builder::setVersion( ::uint16_t value) {
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool CentreApplicationWitness::Reader::hasIdentity() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool CentreApplicationWitness::Builder::hasIdentity() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader CentreApplicationWitness::Reader::getIdentity() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder CentreApplicationWitness::Builder::getIdentity() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void CentreApplicationWitness::Builder::setIdentity( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder CentreApplicationWitness::Builder::initIdentity(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void CentreApplicationWitness::Builder::adoptIdentity(
    ::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> CentreApplicationWitness::Builder::disownIdentity() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline bool CentreApplicationWitness::Reader::hasSourceEpoch() const {
  return !_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline bool CentreApplicationWitness::Builder::hasSourceEpoch() {
  return !_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader CentreApplicationWitness::Reader::getSourceEpoch() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder CentreApplicationWitness::Builder::getSourceEpoch() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline void CentreApplicationWitness::Builder::setSourceEpoch( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder CentreApplicationWitness::Builder::initSourceEpoch(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), size);
}
inline void CentreApplicationWitness::Builder::adoptSourceEpoch(
    ::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> CentreApplicationWitness::Builder::disownSourceEpoch() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}

inline  ::uint64_t CentreApplicationWitness::Reader::getControlMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t CentreApplicationWitness::Builder::getControlMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void CentreApplicationWitness::Builder::setControlMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t CentreApplicationWitness::Reader::getProfileSequence() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t CentreApplicationWitness::Builder::getProfileSequence() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void CentreApplicationWitness::Builder::setProfileSequence( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline bool CentreApplicationWitness::Reader::hasActualCoordinates() const {
  return !_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline bool CentreApplicationWitness::Builder::hasActualCoordinates() {
  return !_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Reader CentreApplicationWitness::Reader::getActualCoordinates() const {
  return ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Builder CentreApplicationWitness::Builder::getActualCoordinates() {
  return ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline void CentreApplicationWitness::Builder::setActualCoordinates( ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), value);
}
inline void CentreApplicationWitness::Builder::setActualCoordinates(::kj::ArrayPtr<const double> value) {
  ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), value);
}
inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Builder CentreApplicationWitness::Builder::initActualCoordinates(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), size);
}
inline void CentreApplicationWitness::Builder::adoptActualCoordinates(
    ::capnp::Orphan< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>> CentreApplicationWitness::Builder::disownActualCoordinates() {
  return ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}

inline bool CentreApplicationWitness::Reader::hasBaselineRevision() const {
  return !_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline bool CentreApplicationWitness::Builder::hasBaselineRevision() {
  return !_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader CentreApplicationWitness::Reader::getBaselineRevision() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder CentreApplicationWitness::Builder::getBaselineRevision() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline void CentreApplicationWitness::Builder::setBaselineRevision( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder CentreApplicationWitness::Builder::initBaselineRevision(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), size);
}
inline void CentreApplicationWitness::Builder::adoptBaselineRevision(
    ::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> CentreApplicationWitness::Builder::disownBaselineRevision() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}

inline bool CentreApplicationWitness::Reader::hasPhysicalModelRevision() const {
  return !_reader.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS).isNull();
}
inline bool CentreApplicationWitness::Builder::hasPhysicalModelRevision() {
  return !_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader CentreApplicationWitness::Reader::getPhysicalModelRevision() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder CentreApplicationWitness::Builder::getPhysicalModelRevision() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}
inline void CentreApplicationWitness::Builder::setPhysicalModelRevision( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder CentreApplicationWitness::Builder::initPhysicalModelRevision(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), size);
}
inline void CentreApplicationWitness::Builder::adoptPhysicalModelRevision(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> CentreApplicationWitness::Builder::disownPhysicalModelRevision() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}

inline  ::uint64_t CentreApplicationWitness::Reader::getOriginalObservedMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t CentreApplicationWitness::Builder::getOriginalObservedMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}
inline void CentreApplicationWitness::Builder::setOriginalObservedMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t CentreApplicationWitness::Reader::getOriginalValidUntilMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t CentreApplicationWitness::Builder::getOriginalValidUntilMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}
inline void CentreApplicationWitness::Builder::setOriginalValidUntilMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS, value);
}

inline double CentreApplicationWitness::Reader::getBaselineFriction() const {
  return _reader.getDataField<double>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}

inline double CentreApplicationWitness::Builder::getBaselineFriction() {
  return _builder.getDataField<double>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}
inline void CentreApplicationWitness::Builder::setBaselineFriction(double value) {
  _builder.setDataField<double>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS, value);
}

inline double CentreApplicationWitness::Reader::getActualFriction() const {
  return _reader.getDataField<double>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS);
}

inline double CentreApplicationWitness::Builder::getActualFriction() {
  return _builder.getDataField<double>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS);
}
inline void CentreApplicationWitness::Builder::setActualFriction(double value) {
  _builder.setDataField<double>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS, value);
}

inline  ::uint16_t LearningTorqueProjection::Reader::getVersion() const {
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline  ::uint16_t LearningTorqueProjection::Builder::getVersion() {
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void LearningTorqueProjection::Builder::setVersion( ::uint16_t value) {
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool LearningTorqueProjection::Reader::hasFamily() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool LearningTorqueProjection::Builder::hasFamily() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader LearningTorqueProjection::Reader::getFamily() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder LearningTorqueProjection::Builder::getFamily() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void LearningTorqueProjection::Builder::setFamily( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder LearningTorqueProjection::Builder::initFamily(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void LearningTorqueProjection::Builder::adoptFamily(
    ::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> LearningTorqueProjection::Builder::disownFamily() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline bool LearningTorqueProjection::Reader::hasFingerprint() const {
  return !_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline bool LearningTorqueProjection::Builder::hasFingerprint() {
  return !_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader LearningTorqueProjection::Reader::getFingerprint() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder LearningTorqueProjection::Builder::getFingerprint() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline void LearningTorqueProjection::Builder::setFingerprint( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder LearningTorqueProjection::Builder::initFingerprint(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), size);
}
inline void LearningTorqueProjection::Builder::adoptFingerprint(
    ::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> LearningTorqueProjection::Builder::disownFingerprint() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}

inline  ::uint64_t LearningTorqueProjection::Reader::getFlags() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t LearningTorqueProjection::Builder::getFlags() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void LearningTorqueProjection::Builder::setFlags( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline bool LearningTorqueProjection::Reader::hasCodecId() const {
  return !_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline bool LearningTorqueProjection::Builder::hasCodecId() {
  return !_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader LearningTorqueProjection::Reader::getCodecId() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder LearningTorqueProjection::Builder::getCodecId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline void LearningTorqueProjection::Builder::setCodecId( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder LearningTorqueProjection::Builder::initCodecId(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), size);
}
inline void LearningTorqueProjection::Builder::adoptCodecId(
    ::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> LearningTorqueProjection::Builder::disownCodecId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}

inline bool LearningTorqueProjection::Reader::hasMappingKind() const {
  return !_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline bool LearningTorqueProjection::Builder::hasMappingKind() {
  return !_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader LearningTorqueProjection::Reader::getMappingKind() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder LearningTorqueProjection::Builder::getMappingKind() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline void LearningTorqueProjection::Builder::setMappingKind( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder LearningTorqueProjection::Builder::initMappingKind(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), size);
}
inline void LearningTorqueProjection::Builder::adoptMappingKind(
    ::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> LearningTorqueProjection::Builder::disownMappingKind() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}

inline  ::uint64_t LearningTorqueProjection::Reader::getFrame() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t LearningTorqueProjection::Builder::getFrame() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void LearningTorqueProjection::Builder::setFrame( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline double LearningTorqueProjection::Reader::getRequestedTorque() const {
  return _reader.getDataField<double>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}

inline double LearningTorqueProjection::Builder::getRequestedTorque() {
  return _builder.getDataField<double>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}
inline void LearningTorqueProjection::Builder::setRequestedTorque(double value) {
  _builder.setDataField<double>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS, value);
}

inline double LearningTorqueProjection::Reader::getCodecInputTorque() const {
  return _reader.getDataField<double>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}

inline double LearningTorqueProjection::Builder::getCodecInputTorque() {
  return _builder.getDataField<double>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}
inline void LearningTorqueProjection::Builder::setCodecInputTorque(double value) {
  _builder.setDataField<double>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS, value);
}

inline  ::int32_t LearningTorqueProjection::Reader::getUnlimitedRaw() const {
  return _reader.getDataField< ::int32_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline  ::int32_t LearningTorqueProjection::Builder::getUnlimitedRaw() {
  return _builder.getDataField< ::int32_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void LearningTorqueProjection::Builder::setUnlimitedRaw( ::int32_t value) {
  _builder.setDataField< ::int32_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline  ::int32_t LearningTorqueProjection::Reader::getFinalRaw() const {
  return _reader.getDataField< ::int32_t>(
      ::capnp::bounded<10>() * ::capnp::ELEMENTS);
}

inline  ::int32_t LearningTorqueProjection::Builder::getFinalRaw() {
  return _builder.getDataField< ::int32_t>(
      ::capnp::bounded<10>() * ::capnp::ELEMENTS);
}
inline void LearningTorqueProjection::Builder::setFinalRaw( ::int32_t value) {
  _builder.setDataField< ::int32_t>(
      ::capnp::bounded<10>() * ::capnp::ELEMENTS, value);
}

inline double LearningTorqueProjection::Reader::getEffectiveMax() const {
  return _reader.getDataField<double>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS);
}

inline double LearningTorqueProjection::Builder::getEffectiveMax() {
  return _builder.getDataField<double>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS);
}
inline void LearningTorqueProjection::Builder::setEffectiveMax(double value) {
  _builder.setDataField<double>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS, value);
}

inline bool LearningTorqueProjection::Reader::hasLookupX() const {
  return !_reader.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS).isNull();
}
inline bool LearningTorqueProjection::Builder::hasLookupX() {
  return !_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Reader LearningTorqueProjection::Reader::getLookupX() const {
  return ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}
inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Builder LearningTorqueProjection::Builder::getLookupX() {
  return ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}
inline void LearningTorqueProjection::Builder::setLookupX( ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), value);
}
inline void LearningTorqueProjection::Builder::setLookupX(::kj::ArrayPtr<const double> value) {
  ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), value);
}
inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Builder LearningTorqueProjection::Builder::initLookupX(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), size);
}
inline void LearningTorqueProjection::Builder::adoptLookupX(
    ::capnp::Orphan< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>> LearningTorqueProjection::Builder::disownLookupX() {
  return ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}

inline bool LearningTorqueProjection::Reader::hasLookupY() const {
  return !_reader.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS).isNull();
}
inline bool LearningTorqueProjection::Builder::hasLookupY() {
  return !_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Reader LearningTorqueProjection::Reader::getLookupY() const {
  return ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::get(_reader.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS));
}
inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Builder LearningTorqueProjection::Builder::getLookupY() {
  return ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::get(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS));
}
inline void LearningTorqueProjection::Builder::setLookupY( ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS), value);
}
inline void LearningTorqueProjection::Builder::setLookupY(::kj::ArrayPtr<const double> value) {
  ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::set(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS), value);
}
inline  ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>::Builder LearningTorqueProjection::Builder::initLookupY(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::init(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS), size);
}
inline void LearningTorqueProjection::Builder::adoptLookupY(
    ::capnp::Orphan< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::adopt(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>> LearningTorqueProjection::Builder::disownLookupY() {
  return ::capnp::_::PointerHelpers< ::capnp::List<double,  ::capnp::Kind::PRIMITIVE>>::disown(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS));
}

inline bool LearningTorqueProjection::Reader::hasLimiterKind() const {
  return !_reader.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS).isNull();
}
inline bool LearningTorqueProjection::Builder::hasLimiterKind() {
  return !_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader LearningTorqueProjection::Reader::getLimiterKind() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder LearningTorqueProjection::Builder::getLimiterKind() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS));
}
inline void LearningTorqueProjection::Builder::setLimiterKind( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder LearningTorqueProjection::Builder::initLimiterKind(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS), size);
}
inline void LearningTorqueProjection::Builder::adoptLimiterKind(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> LearningTorqueProjection::Builder::disownLimiterKind() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS));
}

inline double LearningTorqueProjection::Reader::getPreviousTorque() const {
  return _reader.getDataField<double>(
      ::capnp::bounded<7>() * ::capnp::ELEMENTS);
}

inline double LearningTorqueProjection::Builder::getPreviousTorque() {
  return _builder.getDataField<double>(
      ::capnp::bounded<7>() * ::capnp::ELEMENTS);
}
inline void LearningTorqueProjection::Builder::setPreviousTorque(double value) {
  _builder.setDataField<double>(
      ::capnp::bounded<7>() * ::capnp::ELEMENTS, value);
}

inline double LearningTorqueProjection::Reader::getMeasuredTorque() const {
  return _reader.getDataField<double>(
      ::capnp::bounded<8>() * ::capnp::ELEMENTS);
}

inline double LearningTorqueProjection::Builder::getMeasuredTorque() {
  return _builder.getDataField<double>(
      ::capnp::bounded<8>() * ::capnp::ELEMENTS);
}
inline void LearningTorqueProjection::Builder::setMeasuredTorque(double value) {
  _builder.setDataField<double>(
      ::capnp::bounded<8>() * ::capnp::ELEMENTS, value);
}

inline bool LearningTorqueProjection::Reader::hasLimits() const {
  return !_reader.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS).isNull();
}
inline bool LearningTorqueProjection::Builder::hasLimits() {
  return !_builder.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>::Reader LearningTorqueProjection::Reader::getLimits() const {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>>::get(_reader.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS));
}
inline  ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>::Builder LearningTorqueProjection::Builder::getLimits() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>>::get(_builder.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS));
}
inline void LearningTorqueProjection::Builder::setLimits( ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>>::set(_builder.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS), value);
}
inline  ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>::Builder LearningTorqueProjection::Builder::initLimits(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>>::init(_builder.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS), size);
}
inline void LearningTorqueProjection::Builder::adoptLimits(
    ::capnp::Orphan< ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>> LearningTorqueProjection::Builder::disownLimits() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LearningControlEvidence::StageValue,  ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS));
}

inline bool LearningTorqueProjection::Reader::hasShape() const {
  return !_reader.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS).isNull();
}
inline bool LearningTorqueProjection::Builder::hasShape() {
  return !_builder.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>::Reader LearningTorqueProjection::Reader::getShape() const {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>>::get(_reader.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS));
}
inline  ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>::Builder LearningTorqueProjection::Builder::getShape() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>>::get(_builder.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS));
}
inline void LearningTorqueProjection::Builder::setShape( ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>>::set(_builder.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS), value);
}
inline  ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>::Builder LearningTorqueProjection::Builder::initShape(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>>::init(_builder.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS), size);
}
inline void LearningTorqueProjection::Builder::adoptShape(
    ::capnp::Orphan< ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>> LearningTorqueProjection::Builder::disownShape() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LearningControlEvidence::NamedValue,  ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS));
}

inline bool LearningTorqueProjection::Reader::getSteerRequested() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS);
}

inline bool LearningTorqueProjection::Builder::getSteerRequested() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS);
}
inline void LearningTorqueProjection::Builder::setSteerRequested(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS, value);
}

inline  ::uint32_t LearningTorqueProjection::Reader::getCanAddress() const {
  return _reader.getDataField< ::uint32_t>(
      ::capnp::bounded<11>() * ::capnp::ELEMENTS);
}

inline  ::uint32_t LearningTorqueProjection::Builder::getCanAddress() {
  return _builder.getDataField< ::uint32_t>(
      ::capnp::bounded<11>() * ::capnp::ELEMENTS);
}
inline void LearningTorqueProjection::Builder::setCanAddress( ::uint32_t value) {
  _builder.setDataField< ::uint32_t>(
      ::capnp::bounded<11>() * ::capnp::ELEMENTS, value);
}

inline  ::uint16_t LearningTorqueProjection::Reader::getCanBus() const {
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<36>() * ::capnp::ELEMENTS);
}

inline  ::uint16_t LearningTorqueProjection::Builder::getCanBus() {
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<36>() * ::capnp::ELEMENTS);
}
inline void LearningTorqueProjection::Builder::setCanBus( ::uint16_t value) {
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<36>() * ::capnp::ELEMENTS, value);
}

inline bool LearningTorqueProjection::Reader::hasCanData() const {
  return !_reader.getPointerField(
      ::capnp::bounded<9>() * ::capnp::POINTERS).isNull();
}
inline bool LearningTorqueProjection::Builder::hasCanData() {
  return !_builder.getPointerField(
      ::capnp::bounded<9>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Data::Reader LearningTorqueProjection::Reader::getCanData() const {
  return ::capnp::_::PointerHelpers< ::capnp::Data>::get(_reader.getPointerField(
      ::capnp::bounded<9>() * ::capnp::POINTERS));
}
inline  ::capnp::Data::Builder LearningTorqueProjection::Builder::getCanData() {
  return ::capnp::_::PointerHelpers< ::capnp::Data>::get(_builder.getPointerField(
      ::capnp::bounded<9>() * ::capnp::POINTERS));
}
inline void LearningTorqueProjection::Builder::setCanData( ::capnp::Data::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Data>::set(_builder.getPointerField(
      ::capnp::bounded<9>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Data::Builder LearningTorqueProjection::Builder::initCanData(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Data>::init(_builder.getPointerField(
      ::capnp::bounded<9>() * ::capnp::POINTERS), size);
}
inline void LearningTorqueProjection::Builder::adoptCanData(
    ::capnp::Orphan< ::capnp::Data>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Data>::adopt(_builder.getPointerField(
      ::capnp::bounded<9>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Data> LearningTorqueProjection::Builder::disownCanData() {
  return ::capnp::_::PointerHelpers< ::capnp::Data>::disown(_builder.getPointerField(
      ::capnp::bounded<9>() * ::capnp::POINTERS));
}

inline double LearningTorqueProjection::Reader::getReportedTorque() const {
  return _reader.getDataField<double>(
      ::capnp::bounded<10>() * ::capnp::ELEMENTS);
}

inline double LearningTorqueProjection::Builder::getReportedTorque() {
  return _builder.getDataField<double>(
      ::capnp::bounded<10>() * ::capnp::ELEMENTS);
}
inline void LearningTorqueProjection::Builder::setReportedTorque(double value) {
  _builder.setDataField<double>(
      ::capnp::bounded<10>() * ::capnp::ELEMENTS, value);
}

inline bool LearningTorqueProjection::Reader::getUnlimitedRawPresent() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<17>() * ::capnp::ELEMENTS);
}

inline bool LearningTorqueProjection::Builder::getUnlimitedRawPresent() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<17>() * ::capnp::ELEMENTS);
}
inline void LearningTorqueProjection::Builder::setUnlimitedRawPresent(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<17>() * ::capnp::ELEMENTS, value);
}

inline bool LiveTrackingBinding::Reader::hasIdentity() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool LiveTrackingBinding::Builder::hasIdentity() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader LiveTrackingBinding::Reader::getIdentity() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder LiveTrackingBinding::Builder::getIdentity() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void LiveTrackingBinding::Builder::setIdentity( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder LiveTrackingBinding::Builder::initIdentity(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void LiveTrackingBinding::Builder::adoptIdentity(
    ::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> LiveTrackingBinding::Builder::disownIdentity() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline bool LiveTrackingBinding::Reader::hasCpSha256() const {
  return !_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline bool LiveTrackingBinding::Builder::hasCpSha256() {
  return !_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader LiveTrackingBinding::Reader::getCpSha256() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder LiveTrackingBinding::Builder::getCpSha256() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline void LiveTrackingBinding::Builder::setCpSha256( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder LiveTrackingBinding::Builder::initCpSha256(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), size);
}
inline void LiveTrackingBinding::Builder::adoptCpSha256(
    ::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> LiveTrackingBinding::Builder::disownCpSha256() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}

inline bool LiveTrackingBinding::Reader::hasControllerRevision() const {
  return !_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline bool LiveTrackingBinding::Builder::hasControllerRevision() {
  return !_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader LiveTrackingBinding::Reader::getControllerRevision() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder LiveTrackingBinding::Builder::getControllerRevision() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline void LiveTrackingBinding::Builder::setControllerRevision( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder LiveTrackingBinding::Builder::initControllerRevision(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), size);
}
inline void LiveTrackingBinding::Builder::adoptControllerRevision(
    ::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> LiveTrackingBinding::Builder::disownControllerRevision() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}

inline bool LiveTrackingBinding::Reader::hasBaselineRevision() const {
  return !_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline bool LiveTrackingBinding::Builder::hasBaselineRevision() {
  return !_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader LiveTrackingBinding::Reader::getBaselineRevision() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder LiveTrackingBinding::Builder::getBaselineRevision() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline void LiveTrackingBinding::Builder::setBaselineRevision( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder LiveTrackingBinding::Builder::initBaselineRevision(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), size);
}
inline void LiveTrackingBinding::Builder::adoptBaselineRevision(
    ::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> LiveTrackingBinding::Builder::disownBaselineRevision() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}

inline bool LiveTrackingBinding::Reader::hasSourceEpoch() const {
  return !_reader.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS).isNull();
}
inline bool LiveTrackingBinding::Builder::hasSourceEpoch() {
  return !_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader LiveTrackingBinding::Reader::getSourceEpoch() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder LiveTrackingBinding::Builder::getSourceEpoch() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}
inline void LiveTrackingBinding::Builder::setSourceEpoch( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder LiveTrackingBinding::Builder::initSourceEpoch(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), size);
}
inline void LiveTrackingBinding::Builder::adoptSourceEpoch(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> LiveTrackingBinding::Builder::disownSourceEpoch() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}

inline bool LiveTrackingBinding::Reader::hasResetGeneration() const {
  return !_reader.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS).isNull();
}
inline bool LiveTrackingBinding::Builder::hasResetGeneration() {
  return !_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader LiveTrackingBinding::Reader::getResetGeneration() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder LiveTrackingBinding::Builder::getResetGeneration() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS));
}
inline void LiveTrackingBinding::Builder::setResetGeneration( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder LiveTrackingBinding::Builder::initResetGeneration(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS), size);
}
inline void LiveTrackingBinding::Builder::adoptResetGeneration(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> LiveTrackingBinding::Builder::disownResetGeneration() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS));
}

inline bool LiveTrackingBinding::Reader::hasCalibrationGeneration() const {
  return !_reader.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS).isNull();
}
inline bool LiveTrackingBinding::Builder::hasCalibrationGeneration() {
  return !_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader LiveTrackingBinding::Reader::getCalibrationGeneration() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder LiveTrackingBinding::Builder::getCalibrationGeneration() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS));
}
inline void LiveTrackingBinding::Builder::setCalibrationGeneration( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder LiveTrackingBinding::Builder::initCalibrationGeneration(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS), size);
}
inline void LiveTrackingBinding::Builder::adoptCalibrationGeneration(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> LiveTrackingBinding::Builder::disownCalibrationGeneration() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS));
}

inline bool LiveTrackingBinding::Reader::hasVehicleModelGeneration() const {
  return !_reader.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS).isNull();
}
inline bool LiveTrackingBinding::Builder::hasVehicleModelGeneration() {
  return !_builder.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader LiveTrackingBinding::Reader::getVehicleModelGeneration() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder LiveTrackingBinding::Builder::getVehicleModelGeneration() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS));
}
inline void LiveTrackingBinding::Builder::setVehicleModelGeneration( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder LiveTrackingBinding::Builder::initVehicleModelGeneration(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS), size);
}
inline void LiveTrackingBinding::Builder::adoptVehicleModelGeneration(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> LiveTrackingBinding::Builder::disownVehicleModelGeneration() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS));
}

inline bool LiveTrackingBinding::Reader::hasNativeIdentity() const {
  return !_reader.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS).isNull();
}
inline bool LiveTrackingBinding::Builder::hasNativeIdentity() {
  return !_builder.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader LiveTrackingBinding::Reader::getNativeIdentity() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder LiveTrackingBinding::Builder::getNativeIdentity() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS));
}
inline void LiveTrackingBinding::Builder::setNativeIdentity( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder LiveTrackingBinding::Builder::initNativeIdentity(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS), size);
}
inline void LiveTrackingBinding::Builder::adoptNativeIdentity(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> LiveTrackingBinding::Builder::disownNativeIdentity() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS));
}

inline bool LiveTrackingBinding::Reader::hasPhysicalModelRevision() const {
  return !_reader.getPointerField(
      ::capnp::bounded<9>() * ::capnp::POINTERS).isNull();
}
inline bool LiveTrackingBinding::Builder::hasPhysicalModelRevision() {
  return !_builder.getPointerField(
      ::capnp::bounded<9>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader LiveTrackingBinding::Reader::getPhysicalModelRevision() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<9>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder LiveTrackingBinding::Builder::getPhysicalModelRevision() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<9>() * ::capnp::POINTERS));
}
inline void LiveTrackingBinding::Builder::setPhysicalModelRevision( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<9>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder LiveTrackingBinding::Builder::initPhysicalModelRevision(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<9>() * ::capnp::POINTERS), size);
}
inline void LiveTrackingBinding::Builder::adoptPhysicalModelRevision(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<9>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> LiveTrackingBinding::Builder::disownPhysicalModelRevision() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<9>() * ::capnp::POINTERS));
}

inline bool LiveTrackingBinding::Reader::hasPersistentSourceEpoch() const {
  return !_reader.getPointerField(
      ::capnp::bounded<10>() * ::capnp::POINTERS).isNull();
}
inline bool LiveTrackingBinding::Builder::hasPersistentSourceEpoch() {
  return !_builder.getPointerField(
      ::capnp::bounded<10>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader LiveTrackingBinding::Reader::getPersistentSourceEpoch() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<10>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder LiveTrackingBinding::Builder::getPersistentSourceEpoch() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<10>() * ::capnp::POINTERS));
}
inline void LiveTrackingBinding::Builder::setPersistentSourceEpoch( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<10>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder LiveTrackingBinding::Builder::initPersistentSourceEpoch(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<10>() * ::capnp::POINTERS), size);
}
inline void LiveTrackingBinding::Builder::adoptPersistentSourceEpoch(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<10>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> LiveTrackingBinding::Builder::disownPersistentSourceEpoch() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<10>() * ::capnp::POINTERS));
}

inline bool LiveTrackingBinding::Reader::getNativeRequired() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline bool LiveTrackingBinding::Builder::getNativeRequired() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void LiveTrackingBinding::Builder::setNativeRequired(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline  ::uint16_t LiveTrackingTrial::Reader::getVersion() const {
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline  ::uint16_t LiveTrackingTrial::Builder::getVersion() {
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void LiveTrackingTrial::Builder::setVersion( ::uint16_t value) {
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool LiveTrackingTrial::Reader::hasProtocol() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool LiveTrackingTrial::Builder::hasProtocol() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader LiveTrackingTrial::Reader::getProtocol() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder LiveTrackingTrial::Builder::getProtocol() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void LiveTrackingTrial::Builder::setProtocol( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder LiveTrackingTrial::Builder::initProtocol(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void LiveTrackingTrial::Builder::adoptProtocol(
    ::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> LiveTrackingTrial::Builder::disownProtocol() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline bool LiveTrackingTrial::Reader::hasBinding() const {
  return !_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline bool LiveTrackingTrial::Builder::hasBinding() {
  return !_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline  ::cereal::LiveTrackingBinding::Reader LiveTrackingTrial::Reader::getBinding() const {
  return ::capnp::_::PointerHelpers< ::cereal::LiveTrackingBinding>::get(_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline  ::cereal::LiveTrackingBinding::Builder LiveTrackingTrial::Builder::getBinding() {
  return ::capnp::_::PointerHelpers< ::cereal::LiveTrackingBinding>::get(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
#if !CAPNP_LITE
inline  ::cereal::LiveTrackingBinding::Pipeline LiveTrackingTrial::Pipeline::getBinding() {
  return  ::cereal::LiveTrackingBinding::Pipeline(_typeless.getPointerField(1));
}
#endif  // !CAPNP_LITE
inline void LiveTrackingTrial::Builder::setBinding( ::cereal::LiveTrackingBinding::Reader value) {
  ::capnp::_::PointerHelpers< ::cereal::LiveTrackingBinding>::set(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), value);
}
inline  ::cereal::LiveTrackingBinding::Builder LiveTrackingTrial::Builder::initBinding() {
  return ::capnp::_::PointerHelpers< ::cereal::LiveTrackingBinding>::init(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline void LiveTrackingTrial::Builder::adoptBinding(
    ::capnp::Orphan< ::cereal::LiveTrackingBinding>&& value) {
  ::capnp::_::PointerHelpers< ::cereal::LiveTrackingBinding>::adopt(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::cereal::LiveTrackingBinding> LiveTrackingTrial::Builder::disownBinding() {
  return ::capnp::_::PointerHelpers< ::cereal::LiveTrackingBinding>::disown(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}

inline bool LiveTrackingTrial::Reader::hasTrialId() const {
  return !_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline bool LiveTrackingTrial::Builder::hasTrialId() {
  return !_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader LiveTrackingTrial::Reader::getTrialId() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder LiveTrackingTrial::Builder::getTrialId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline void LiveTrackingTrial::Builder::setTrialId( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder LiveTrackingTrial::Builder::initTrialId(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), size);
}
inline void LiveTrackingTrial::Builder::adoptTrialId(
    ::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> LiveTrackingTrial::Builder::disownTrialId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}

inline  ::uint64_t LiveTrackingTrial::Reader::getSequence() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t LiveTrackingTrial::Builder::getSequence() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void LiveTrackingTrial::Builder::setSequence( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline bool LiveTrackingTrial::Reader::hasPhase() const {
  return !_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline bool LiveTrackingTrial::Builder::hasPhase() {
  return !_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader LiveTrackingTrial::Reader::getPhase() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder LiveTrackingTrial::Builder::getPhase() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline void LiveTrackingTrial::Builder::setPhase( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder LiveTrackingTrial::Builder::initPhase(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), size);
}
inline void LiveTrackingTrial::Builder::adoptPhase(
    ::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> LiveTrackingTrial::Builder::disownPhase() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}

inline bool LiveTrackingTrial::Reader::hasGroup() const {
  return !_reader.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS).isNull();
}
inline bool LiveTrackingTrial::Builder::hasGroup() {
  return !_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader LiveTrackingTrial::Reader::getGroup() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder LiveTrackingTrial::Builder::getGroup() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}
inline void LiveTrackingTrial::Builder::setGroup( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder LiveTrackingTrial::Builder::initGroup(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), size);
}
inline void LiveTrackingTrial::Builder::adoptGroup(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> LiveTrackingTrial::Builder::disownGroup() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}

inline bool LiveTrackingTrial::Reader::hasNames() const {
  return !_reader.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS).isNull();
}
inline bool LiveTrackingTrial::Builder::hasNames() {
  return !_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>::Reader LiveTrackingTrial::Reader::getNames() const {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>::get(_reader.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS));
}
inline  ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>::Builder LiveTrackingTrial::Builder::getNames() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>::get(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS));
}
inline void LiveTrackingTrial::Builder::setNames( ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>::set(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS), value);
}
inline void LiveTrackingTrial::Builder::setNames(::kj::ArrayPtr<const  ::capnp::Text::Reader> value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>::set(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS), value);
}
inline  ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>::Builder LiveTrackingTrial::Builder::initNames(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>::init(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS), size);
}
inline void LiveTrackingTrial::Builder::adoptNames(
    ::capnp::Orphan< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>::adopt(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>> LiveTrackingTrial::Builder::disownNames() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>::disown(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS));
}

inline bool LiveTrackingTrial::Reader::hasBaseline() const {
  return !_reader.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS).isNull();
}
inline bool LiveTrackingTrial::Builder::hasBaseline() {
  return !_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>::Reader LiveTrackingTrial::Reader::getBaseline() const {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>>::get(_reader.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS));
}
inline  ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>::Builder LiveTrackingTrial::Builder::getBaseline() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>>::get(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS));
}
inline void LiveTrackingTrial::Builder::setBaseline( ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>>::set(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS), value);
}
inline  ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>::Builder LiveTrackingTrial::Builder::initBaseline(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>>::init(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS), size);
}
inline void LiveTrackingTrial::Builder::adoptBaseline(
    ::capnp::Orphan< ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>> LiveTrackingTrial::Builder::disownBaseline() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS));
}

inline bool LiveTrackingTrial::Reader::hasTarget() const {
  return !_reader.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS).isNull();
}
inline bool LiveTrackingTrial::Builder::hasTarget() {
  return !_builder.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>::Reader LiveTrackingTrial::Reader::getTarget() const {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>>::get(_reader.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS));
}
inline  ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>::Builder LiveTrackingTrial::Builder::getTarget() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>>::get(_builder.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS));
}
inline void LiveTrackingTrial::Builder::setTarget( ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>>::set(_builder.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS), value);
}
inline  ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>::Builder LiveTrackingTrial::Builder::initTarget(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>>::init(_builder.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS), size);
}
inline void LiveTrackingTrial::Builder::adoptTarget(
    ::capnp::Orphan< ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>> LiveTrackingTrial::Builder::disownTarget() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS));
}

inline bool LiveTrackingTrial::Reader::hasBaselineSha256() const {
  return !_reader.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS).isNull();
}
inline bool LiveTrackingTrial::Builder::hasBaselineSha256() {
  return !_builder.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader LiveTrackingTrial::Reader::getBaselineSha256() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder LiveTrackingTrial::Builder::getBaselineSha256() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS));
}
inline void LiveTrackingTrial::Builder::setBaselineSha256( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder LiveTrackingTrial::Builder::initBaselineSha256(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS), size);
}
inline void LiveTrackingTrial::Builder::adoptBaselineSha256(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> LiveTrackingTrial::Builder::disownBaselineSha256() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS));
}

inline bool LiveTrackingTrial::Reader::hasTargetSha256() const {
  return !_reader.getPointerField(
      ::capnp::bounded<9>() * ::capnp::POINTERS).isNull();
}
inline bool LiveTrackingTrial::Builder::hasTargetSha256() {
  return !_builder.getPointerField(
      ::capnp::bounded<9>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader LiveTrackingTrial::Reader::getTargetSha256() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<9>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder LiveTrackingTrial::Builder::getTargetSha256() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<9>() * ::capnp::POINTERS));
}
inline void LiveTrackingTrial::Builder::setTargetSha256( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<9>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder LiveTrackingTrial::Builder::initTargetSha256(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<9>() * ::capnp::POINTERS), size);
}
inline void LiveTrackingTrial::Builder::adoptTargetSha256(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<9>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> LiveTrackingTrial::Builder::disownTargetSha256() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<9>() * ::capnp::POINTERS));
}

inline  ::uint64_t LiveTrackingTrial::Reader::getStartedMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t LiveTrackingTrial::Builder::getStartedMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void LiveTrackingTrial::Builder::setStartedMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t LiveTrackingTrial::Reader::getObservedMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t LiveTrackingTrial::Builder::getObservedMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}
inline void LiveTrackingTrial::Builder::setObservedMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t LiveTrackingTrial::Reader::getValidUntilMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t LiveTrackingTrial::Builder::getValidUntilMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}
inline void LiveTrackingTrial::Builder::setValidUntilMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS, value);
}

inline bool LiveTrackingTrial::Reader::hasResponseWitness() const {
  return !_reader.getPointerField(
      ::capnp::bounded<10>() * ::capnp::POINTERS).isNull();
}
inline bool LiveTrackingTrial::Builder::hasResponseWitness() {
  return !_builder.getPointerField(
      ::capnp::bounded<10>() * ::capnp::POINTERS).isNull();
}
inline  ::cereal::LiveTrackingResponseWitness::Reader LiveTrackingTrial::Reader::getResponseWitness() const {
  return ::capnp::_::PointerHelpers< ::cereal::LiveTrackingResponseWitness>::get(_reader.getPointerField(
      ::capnp::bounded<10>() * ::capnp::POINTERS));
}
inline  ::cereal::LiveTrackingResponseWitness::Builder LiveTrackingTrial::Builder::getResponseWitness() {
  return ::capnp::_::PointerHelpers< ::cereal::LiveTrackingResponseWitness>::get(_builder.getPointerField(
      ::capnp::bounded<10>() * ::capnp::POINTERS));
}
#if !CAPNP_LITE
inline  ::cereal::LiveTrackingResponseWitness::Pipeline LiveTrackingTrial::Pipeline::getResponseWitness() {
  return  ::cereal::LiveTrackingResponseWitness::Pipeline(_typeless.getPointerField(10));
}
#endif  // !CAPNP_LITE
inline void LiveTrackingTrial::Builder::setResponseWitness( ::cereal::LiveTrackingResponseWitness::Reader value) {
  ::capnp::_::PointerHelpers< ::cereal::LiveTrackingResponseWitness>::set(_builder.getPointerField(
      ::capnp::bounded<10>() * ::capnp::POINTERS), value);
}
inline  ::cereal::LiveTrackingResponseWitness::Builder LiveTrackingTrial::Builder::initResponseWitness() {
  return ::capnp::_::PointerHelpers< ::cereal::LiveTrackingResponseWitness>::init(_builder.getPointerField(
      ::capnp::bounded<10>() * ::capnp::POINTERS));
}
inline void LiveTrackingTrial::Builder::adoptResponseWitness(
    ::capnp::Orphan< ::cereal::LiveTrackingResponseWitness>&& value) {
  ::capnp::_::PointerHelpers< ::cereal::LiveTrackingResponseWitness>::adopt(_builder.getPointerField(
      ::capnp::bounded<10>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::cereal::LiveTrackingResponseWitness> LiveTrackingTrial::Builder::disownResponseWitness() {
  return ::capnp::_::PointerHelpers< ::cereal::LiveTrackingResponseWitness>::disown(_builder.getPointerField(
      ::capnp::bounded<10>() * ::capnp::POINTERS));
}

inline  ::uint64_t LiveTrackingTrial::Reader::getTargetSequence() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t LiveTrackingTrial::Builder::getTargetSequence() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}
inline void LiveTrackingTrial::Builder::setTargetSequence( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t LiveTrackingTrial::Reader::getDeadlineMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t LiveTrackingTrial::Builder::getDeadlineMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS);
}
inline void LiveTrackingTrial::Builder::setDeadlineMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS, value);
}

inline bool LiveTrackingTrial::Coordinate::Reader::hasName() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool LiveTrackingTrial::Coordinate::Builder::hasName() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader LiveTrackingTrial::Coordinate::Reader::getName() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder LiveTrackingTrial::Coordinate::Builder::getName() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void LiveTrackingTrial::Coordinate::Builder::setName( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder LiveTrackingTrial::Coordinate::Builder::initName(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void LiveTrackingTrial::Coordinate::Builder::adoptName(
    ::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> LiveTrackingTrial::Coordinate::Builder::disownName() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline double LiveTrackingTrial::Coordinate::Reader::getValue() const {
  return _reader.getDataField<double>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline double LiveTrackingTrial::Coordinate::Builder::getValue() {
  return _builder.getDataField<double>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void LiveTrackingTrial::Coordinate::Builder::setValue(double value) {
  _builder.setDataField<double>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline  ::uint16_t LiveTrackingApplication::Reader::getVersion() const {
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline  ::uint16_t LiveTrackingApplication::Builder::getVersion() {
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void LiveTrackingApplication::Builder::setVersion( ::uint16_t value) {
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool LiveTrackingApplication::Reader::hasBinding() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool LiveTrackingApplication::Builder::hasBinding() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::cereal::LiveTrackingBinding::Reader LiveTrackingApplication::Reader::getBinding() const {
  return ::capnp::_::PointerHelpers< ::cereal::LiveTrackingBinding>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::cereal::LiveTrackingBinding::Builder LiveTrackingApplication::Builder::getBinding() {
  return ::capnp::_::PointerHelpers< ::cereal::LiveTrackingBinding>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
#if !CAPNP_LITE
inline  ::cereal::LiveTrackingBinding::Pipeline LiveTrackingApplication::Pipeline::getBinding() {
  return  ::cereal::LiveTrackingBinding::Pipeline(_typeless.getPointerField(0));
}
#endif  // !CAPNP_LITE
inline void LiveTrackingApplication::Builder::setBinding( ::cereal::LiveTrackingBinding::Reader value) {
  ::capnp::_::PointerHelpers< ::cereal::LiveTrackingBinding>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::cereal::LiveTrackingBinding::Builder LiveTrackingApplication::Builder::initBinding() {
  return ::capnp::_::PointerHelpers< ::cereal::LiveTrackingBinding>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void LiveTrackingApplication::Builder::adoptBinding(
    ::capnp::Orphan< ::cereal::LiveTrackingBinding>&& value) {
  ::capnp::_::PointerHelpers< ::cereal::LiveTrackingBinding>::adopt(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::cereal::LiveTrackingBinding> LiveTrackingApplication::Builder::disownBinding() {
  return ::capnp::_::PointerHelpers< ::cereal::LiveTrackingBinding>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline bool LiveTrackingApplication::Reader::hasTrialId() const {
  return !_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline bool LiveTrackingApplication::Builder::hasTrialId() {
  return !_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader LiveTrackingApplication::Reader::getTrialId() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder LiveTrackingApplication::Builder::getTrialId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline void LiveTrackingApplication::Builder::setTrialId( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder LiveTrackingApplication::Builder::initTrialId(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), size);
}
inline void LiveTrackingApplication::Builder::adoptTrialId(
    ::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> LiveTrackingApplication::Builder::disownTrialId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}

inline  ::uint64_t LiveTrackingApplication::Reader::getSequence() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t LiveTrackingApplication::Builder::getSequence() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void LiveTrackingApplication::Builder::setSequence( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t LiveTrackingApplication::Reader::getControlMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t LiveTrackingApplication::Builder::getControlMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void LiveTrackingApplication::Builder::setControlMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline bool LiveTrackingApplication::Reader::hasStatus() const {
  return !_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline bool LiveTrackingApplication::Builder::hasStatus() {
  return !_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader LiveTrackingApplication::Reader::getStatus() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder LiveTrackingApplication::Builder::getStatus() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline void LiveTrackingApplication::Builder::setStatus( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder LiveTrackingApplication::Builder::initStatus(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), size);
}
inline void LiveTrackingApplication::Builder::adoptStatus(
    ::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> LiveTrackingApplication::Builder::disownStatus() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}

inline bool LiveTrackingApplication::Reader::hasApplied() const {
  return !_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline bool LiveTrackingApplication::Builder::hasApplied() {
  return !_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>::Reader LiveTrackingApplication::Reader::getApplied() const {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>>::get(_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline  ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>::Builder LiveTrackingApplication::Builder::getApplied() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>>::get(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline void LiveTrackingApplication::Builder::setApplied( ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>>::set(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), value);
}
inline  ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>::Builder LiveTrackingApplication::Builder::initApplied(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>>::init(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), size);
}
inline void LiveTrackingApplication::Builder::adoptApplied(
    ::capnp::Orphan< ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>> LiveTrackingApplication::Builder::disownApplied() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}

inline bool LiveTrackingApplication::Reader::hasAppliedSha256() const {
  return !_reader.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS).isNull();
}
inline bool LiveTrackingApplication::Builder::hasAppliedSha256() {
  return !_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader LiveTrackingApplication::Reader::getAppliedSha256() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder LiveTrackingApplication::Builder::getAppliedSha256() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}
inline void LiveTrackingApplication::Builder::setAppliedSha256( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder LiveTrackingApplication::Builder::initAppliedSha256(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), size);
}
inline void LiveTrackingApplication::Builder::adoptAppliedSha256(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> LiveTrackingApplication::Builder::disownAppliedSha256() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}

inline bool LiveTrackingApplication::Reader::hasConfirmedTargetSha256() const {
  return !_reader.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS).isNull();
}
inline bool LiveTrackingApplication::Builder::hasConfirmedTargetSha256() {
  return !_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader LiveTrackingApplication::Reader::getConfirmedTargetSha256() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder LiveTrackingApplication::Builder::getConfirmedTargetSha256() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS));
}
inline void LiveTrackingApplication::Builder::setConfirmedTargetSha256( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder LiveTrackingApplication::Builder::initConfirmedTargetSha256(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS), size);
}
inline void LiveTrackingApplication::Builder::adoptConfirmedTargetSha256(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> LiveTrackingApplication::Builder::disownConfirmedTargetSha256() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS));
}

inline bool LiveTrackingApplication::Reader::hasReason() const {
  return !_reader.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS).isNull();
}
inline bool LiveTrackingApplication::Builder::hasReason() {
  return !_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader LiveTrackingApplication::Reader::getReason() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder LiveTrackingApplication::Builder::getReason() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS));
}
inline void LiveTrackingApplication::Builder::setReason( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder LiveTrackingApplication::Builder::initReason(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS), size);
}
inline void LiveTrackingApplication::Builder::adoptReason(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> LiveTrackingApplication::Builder::disownReason() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS));
}

inline  ::uint64_t LiveTrackingApplication::Reader::getTargetSequence() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t LiveTrackingApplication::Builder::getTargetSequence() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}
inline void LiveTrackingApplication::Builder::setTargetSequence( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS, value);
}

inline  ::uint16_t LiveTrackingRestore::Reader::getVersion() const {
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline  ::uint16_t LiveTrackingRestore::Builder::getVersion() {
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void LiveTrackingRestore::Builder::setVersion( ::uint16_t value) {
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool LiveTrackingRestore::Reader::hasProtocol() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool LiveTrackingRestore::Builder::hasProtocol() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader LiveTrackingRestore::Reader::getProtocol() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder LiveTrackingRestore::Builder::getProtocol() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void LiveTrackingRestore::Builder::setProtocol( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder LiveTrackingRestore::Builder::initProtocol(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void LiveTrackingRestore::Builder::adoptProtocol(
    ::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> LiveTrackingRestore::Builder::disownProtocol() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline bool LiveTrackingRestore::Reader::hasBinding() const {
  return !_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline bool LiveTrackingRestore::Builder::hasBinding() {
  return !_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline  ::cereal::LiveTrackingBinding::Reader LiveTrackingRestore::Reader::getBinding() const {
  return ::capnp::_::PointerHelpers< ::cereal::LiveTrackingBinding>::get(_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline  ::cereal::LiveTrackingBinding::Builder LiveTrackingRestore::Builder::getBinding() {
  return ::capnp::_::PointerHelpers< ::cereal::LiveTrackingBinding>::get(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
#if !CAPNP_LITE
inline  ::cereal::LiveTrackingBinding::Pipeline LiveTrackingRestore::Pipeline::getBinding() {
  return  ::cereal::LiveTrackingBinding::Pipeline(_typeless.getPointerField(1));
}
#endif  // !CAPNP_LITE
inline void LiveTrackingRestore::Builder::setBinding( ::cereal::LiveTrackingBinding::Reader value) {
  ::capnp::_::PointerHelpers< ::cereal::LiveTrackingBinding>::set(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), value);
}
inline  ::cereal::LiveTrackingBinding::Builder LiveTrackingRestore::Builder::initBinding() {
  return ::capnp::_::PointerHelpers< ::cereal::LiveTrackingBinding>::init(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline void LiveTrackingRestore::Builder::adoptBinding(
    ::capnp::Orphan< ::cereal::LiveTrackingBinding>&& value) {
  ::capnp::_::PointerHelpers< ::cereal::LiveTrackingBinding>::adopt(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::cereal::LiveTrackingBinding> LiveTrackingRestore::Builder::disownBinding() {
  return ::capnp::_::PointerHelpers< ::cereal::LiveTrackingBinding>::disown(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}

inline bool LiveTrackingRestore::Reader::hasHistoryScope() const {
  return !_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline bool LiveTrackingRestore::Builder::hasHistoryScope() {
  return !_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader LiveTrackingRestore::Reader::getHistoryScope() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder LiveTrackingRestore::Builder::getHistoryScope() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline void LiveTrackingRestore::Builder::setHistoryScope( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder LiveTrackingRestore::Builder::initHistoryScope(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), size);
}
inline void LiveTrackingRestore::Builder::adoptHistoryScope(
    ::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> LiveTrackingRestore::Builder::disownHistoryScope() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}

inline bool LiveTrackingRestore::Reader::hasHistoryTrialId() const {
  return !_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline bool LiveTrackingRestore::Builder::hasHistoryTrialId() {
  return !_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader LiveTrackingRestore::Reader::getHistoryTrialId() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder LiveTrackingRestore::Builder::getHistoryTrialId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline void LiveTrackingRestore::Builder::setHistoryTrialId( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder LiveTrackingRestore::Builder::initHistoryTrialId(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), size);
}
inline void LiveTrackingRestore::Builder::adoptHistoryTrialId(
    ::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> LiveTrackingRestore::Builder::disownHistoryTrialId() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}

inline bool LiveTrackingRestore::Reader::hasTarget() const {
  return !_reader.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS).isNull();
}
inline bool LiveTrackingRestore::Builder::hasTarget() {
  return !_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>::Reader LiveTrackingRestore::Reader::getTarget() const {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>>::get(_reader.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}
inline  ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>::Builder LiveTrackingRestore::Builder::getTarget() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>>::get(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}
inline void LiveTrackingRestore::Builder::setTarget( ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>>::set(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), value);
}
inline  ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>::Builder LiveTrackingRestore::Builder::initTarget(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>>::init(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), size);
}
inline void LiveTrackingRestore::Builder::adoptTarget(
    ::capnp::Orphan< ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>> LiveTrackingRestore::Builder::disownTarget() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::cereal::LiveTrackingTrial::Coordinate,  ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}

inline bool LiveTrackingRestore::Reader::hasTargetSha256() const {
  return !_reader.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS).isNull();
}
inline bool LiveTrackingRestore::Builder::hasTargetSha256() {
  return !_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader LiveTrackingRestore::Reader::getTargetSha256() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder LiveTrackingRestore::Builder::getTargetSha256() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS));
}
inline void LiveTrackingRestore::Builder::setTargetSha256( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder LiveTrackingRestore::Builder::initTargetSha256(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS), size);
}
inline void LiveTrackingRestore::Builder::adoptTargetSha256(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> LiveTrackingRestore::Builder::disownTargetSha256() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS));
}

inline  ::uint64_t LiveTrackingRestore::Reader::getSequence() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t LiveTrackingRestore::Builder::getSequence() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void LiveTrackingRestore::Builder::setSequence( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t LiveTrackingRestore::Reader::getObservedMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t LiveTrackingRestore::Builder::getObservedMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void LiveTrackingRestore::Builder::setObservedMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t LiveTrackingRestore::Reader::getValidUntilMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t LiveTrackingRestore::Builder::getValidUntilMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}
inline void LiveTrackingRestore::Builder::setValidUntilMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS, value);
}

inline bool LiveTrackingRestore::Reader::hasResponseWitness() const {
  return !_reader.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS).isNull();
}
inline bool LiveTrackingRestore::Builder::hasResponseWitness() {
  return !_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS).isNull();
}
inline  ::cereal::LiveTrackingResponseWitness::Reader LiveTrackingRestore::Reader::getResponseWitness() const {
  return ::capnp::_::PointerHelpers< ::cereal::LiveTrackingResponseWitness>::get(_reader.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS));
}
inline  ::cereal::LiveTrackingResponseWitness::Builder LiveTrackingRestore::Builder::getResponseWitness() {
  return ::capnp::_::PointerHelpers< ::cereal::LiveTrackingResponseWitness>::get(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS));
}
#if !CAPNP_LITE
inline  ::cereal::LiveTrackingResponseWitness::Pipeline LiveTrackingRestore::Pipeline::getResponseWitness() {
  return  ::cereal::LiveTrackingResponseWitness::Pipeline(_typeless.getPointerField(6));
}
#endif  // !CAPNP_LITE
inline void LiveTrackingRestore::Builder::setResponseWitness( ::cereal::LiveTrackingResponseWitness::Reader value) {
  ::capnp::_::PointerHelpers< ::cereal::LiveTrackingResponseWitness>::set(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS), value);
}
inline  ::cereal::LiveTrackingResponseWitness::Builder LiveTrackingRestore::Builder::initResponseWitness() {
  return ::capnp::_::PointerHelpers< ::cereal::LiveTrackingResponseWitness>::init(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS));
}
inline void LiveTrackingRestore::Builder::adoptResponseWitness(
    ::capnp::Orphan< ::cereal::LiveTrackingResponseWitness>&& value) {
  ::capnp::_::PointerHelpers< ::cereal::LiveTrackingResponseWitness>::adopt(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::cereal::LiveTrackingResponseWitness> LiveTrackingRestore::Builder::disownResponseWitness() {
  return ::capnp::_::PointerHelpers< ::cereal::LiveTrackingResponseWitness>::disown(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS));
}

inline bool LiveTrackingResponseCertificate::Reader::hasVersion() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool LiveTrackingResponseCertificate::Builder::hasVersion() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader LiveTrackingResponseCertificate::Reader::getVersion() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder LiveTrackingResponseCertificate::Builder::getVersion() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void LiveTrackingResponseCertificate::Builder::setVersion( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder LiveTrackingResponseCertificate::Builder::initVersion(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void LiveTrackingResponseCertificate::Builder::adoptVersion(
    ::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> LiveTrackingResponseCertificate::Builder::disownVersion() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline bool LiveTrackingResponseCertificate::Reader::hasModelRevision() const {
  return !_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline bool LiveTrackingResponseCertificate::Builder::hasModelRevision() {
  return !_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader LiveTrackingResponseCertificate::Reader::getModelRevision() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder LiveTrackingResponseCertificate::Builder::getModelRevision() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline void LiveTrackingResponseCertificate::Builder::setModelRevision( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder LiveTrackingResponseCertificate::Builder::initModelRevision(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), size);
}
inline void LiveTrackingResponseCertificate::Builder::adoptModelRevision(
    ::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> LiveTrackingResponseCertificate::Builder::disownModelRevision() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}

inline  ::uint64_t LiveTrackingResponseCertificate::Reader::getLagNs() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t LiveTrackingResponseCertificate::Builder::getLagNs() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void LiveTrackingResponseCertificate::Builder::setLagNs( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline double LiveTrackingResponseCertificate::Reader::getSlope() const {
  return _reader.getDataField<double>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline double LiveTrackingResponseCertificate::Builder::getSlope() {
  return _builder.getDataField<double>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void LiveTrackingResponseCertificate::Builder::setSlope(double value) {
  _builder.setDataField<double>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline double LiveTrackingResponseCertificate::Reader::getIntercept() const {
  return _reader.getDataField<double>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline double LiveTrackingResponseCertificate::Builder::getIntercept() {
  return _builder.getDataField<double>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void LiveTrackingResponseCertificate::Builder::setIntercept(double value) {
  _builder.setDataField<double>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline double LiveTrackingResponseCertificate::Reader::getCommandLow() const {
  return _reader.getDataField<double>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}

inline double LiveTrackingResponseCertificate::Builder::getCommandLow() {
  return _builder.getDataField<double>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}
inline void LiveTrackingResponseCertificate::Builder::setCommandLow(double value) {
  _builder.setDataField<double>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS, value);
}

inline double LiveTrackingResponseCertificate::Reader::getCommandHigh() const {
  return _reader.getDataField<double>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}

inline double LiveTrackingResponseCertificate::Builder::getCommandHigh() {
  return _builder.getDataField<double>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}
inline void LiveTrackingResponseCertificate::Builder::setCommandHigh(double value) {
  _builder.setDataField<double>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS, value);
}

inline double LiveTrackingResponseCertificate::Reader::getHeldoutRmse() const {
  return _reader.getDataField<double>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}

inline double LiveTrackingResponseCertificate::Builder::getHeldoutRmse() {
  return _builder.getDataField<double>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}
inline void LiveTrackingResponseCertificate::Builder::setHeldoutRmse(double value) {
  _builder.setDataField<double>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS, value);
}

inline bool LiveTrackingResponseCertificate::Reader::hasTrainBlockIds() const {
  return !_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline bool LiveTrackingResponseCertificate::Builder::hasTrainBlockIds() {
  return !_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>::Reader LiveTrackingResponseCertificate::Reader::getTrainBlockIds() const {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>::get(_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline  ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>::Builder LiveTrackingResponseCertificate::Builder::getTrainBlockIds() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>::get(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline void LiveTrackingResponseCertificate::Builder::setTrainBlockIds( ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>::set(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), value);
}
inline void LiveTrackingResponseCertificate::Builder::setTrainBlockIds(::kj::ArrayPtr<const  ::capnp::Text::Reader> value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>::set(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), value);
}
inline  ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>::Builder LiveTrackingResponseCertificate::Builder::initTrainBlockIds(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>::init(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), size);
}
inline void LiveTrackingResponseCertificate::Builder::adoptTrainBlockIds(
    ::capnp::Orphan< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>::adopt(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>> LiveTrackingResponseCertificate::Builder::disownTrainBlockIds() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>::disown(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}

inline bool LiveTrackingResponseCertificate::Reader::hasHeldoutBlockIds() const {
  return !_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline bool LiveTrackingResponseCertificate::Builder::hasHeldoutBlockIds() {
  return !_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>::Reader LiveTrackingResponseCertificate::Reader::getHeldoutBlockIds() const {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>::get(_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline  ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>::Builder LiveTrackingResponseCertificate::Builder::getHeldoutBlockIds() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>::get(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline void LiveTrackingResponseCertificate::Builder::setHeldoutBlockIds( ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>::set(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), value);
}
inline void LiveTrackingResponseCertificate::Builder::setHeldoutBlockIds(::kj::ArrayPtr<const  ::capnp::Text::Reader> value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>::set(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), value);
}
inline  ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>::Builder LiveTrackingResponseCertificate::Builder::initHeldoutBlockIds(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>::init(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), size);
}
inline void LiveTrackingResponseCertificate::Builder::adoptHeldoutBlockIds(
    ::capnp::Orphan< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>::adopt(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>> LiveTrackingResponseCertificate::Builder::disownHeldoutBlockIds() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text,  ::capnp::Kind::BLOB>>::disown(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}

inline bool LiveTrackingResponseCertificate::Reader::hasSourceInventorySha256() const {
  return !_reader.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS).isNull();
}
inline bool LiveTrackingResponseCertificate::Builder::hasSourceInventorySha256() {
  return !_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader LiveTrackingResponseCertificate::Reader::getSourceInventorySha256() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder LiveTrackingResponseCertificate::Builder::getSourceInventorySha256() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}
inline void LiveTrackingResponseCertificate::Builder::setSourceInventorySha256( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder LiveTrackingResponseCertificate::Builder::initSourceInventorySha256(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), size);
}
inline void LiveTrackingResponseCertificate::Builder::adoptSourceInventorySha256(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> LiveTrackingResponseCertificate::Builder::disownSourceInventorySha256() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}

inline bool LiveTrackingResponseCertificate::Reader::hasIdentificationSha256() const {
  return !_reader.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS).isNull();
}
inline bool LiveTrackingResponseCertificate::Builder::hasIdentificationSha256() {
  return !_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader LiveTrackingResponseCertificate::Reader::getIdentificationSha256() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder LiveTrackingResponseCertificate::Builder::getIdentificationSha256() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS));
}
inline void LiveTrackingResponseCertificate::Builder::setIdentificationSha256( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder LiveTrackingResponseCertificate::Builder::initIdentificationSha256(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS), size);
}
inline void LiveTrackingResponseCertificate::Builder::adoptIdentificationSha256(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> LiveTrackingResponseCertificate::Builder::disownIdentificationSha256() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS));
}

inline  ::uint64_t LiveTrackingResponseCertificate::Reader::getIdentifiedMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t LiveTrackingResponseCertificate::Builder::getIdentifiedMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS);
}
inline void LiveTrackingResponseCertificate::Builder::setIdentifiedMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS, value);
}

inline bool LiveTrackingResponseCertificate::Reader::hasProvenance() const {
  return !_reader.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS).isNull();
}
inline bool LiveTrackingResponseCertificate::Builder::hasProvenance() {
  return !_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader LiveTrackingResponseCertificate::Reader::getProvenance() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder LiveTrackingResponseCertificate::Builder::getProvenance() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS));
}
inline void LiveTrackingResponseCertificate::Builder::setProvenance( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder LiveTrackingResponseCertificate::Builder::initProvenance(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS), size);
}
inline void LiveTrackingResponseCertificate::Builder::adoptProvenance(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> LiveTrackingResponseCertificate::Builder::disownProvenance() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<6>() * ::capnp::POINTERS));
}

inline bool LiveTrackingResponseCertificate::Reader::hasParentModelRevision() const {
  return !_reader.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS).isNull();
}
inline bool LiveTrackingResponseCertificate::Builder::hasParentModelRevision() {
  return !_builder.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader LiveTrackingResponseCertificate::Reader::getParentModelRevision() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder LiveTrackingResponseCertificate::Builder::getParentModelRevision() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS));
}
inline void LiveTrackingResponseCertificate::Builder::setParentModelRevision( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder LiveTrackingResponseCertificate::Builder::initParentModelRevision(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS), size);
}
inline void LiveTrackingResponseCertificate::Builder::adoptParentModelRevision(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> LiveTrackingResponseCertificate::Builder::disownParentModelRevision() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<7>() * ::capnp::POINTERS));
}

inline bool LiveTrackingResponseCertificate::Reader::hasRequalificationSha256() const {
  return !_reader.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS).isNull();
}
inline bool LiveTrackingResponseCertificate::Builder::hasRequalificationSha256() {
  return !_builder.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS).isNull();
}
inline  ::capnp::Text::Reader LiveTrackingResponseCertificate::Reader::getRequalificationSha256() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS));
}
inline  ::capnp::Text::Builder LiveTrackingResponseCertificate::Builder::getRequalificationSha256() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS));
}
inline void LiveTrackingResponseCertificate::Builder::setRequalificationSha256( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS), value);
}
inline  ::capnp::Text::Builder LiveTrackingResponseCertificate::Builder::initRequalificationSha256(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS), size);
}
inline void LiveTrackingResponseCertificate::Builder::adoptRequalificationSha256(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> LiveTrackingResponseCertificate::Builder::disownRequalificationSha256() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<8>() * ::capnp::POINTERS));
}

inline bool LiveTrackingResponseWitness::Reader::hasCertificate() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool LiveTrackingResponseWitness::Builder::hasCertificate() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline  ::cereal::LiveTrackingResponseCertificate::Reader LiveTrackingResponseWitness::Reader::getCertificate() const {
  return ::capnp::_::PointerHelpers< ::cereal::LiveTrackingResponseCertificate>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline  ::cereal::LiveTrackingResponseCertificate::Builder LiveTrackingResponseWitness::Builder::getCertificate() {
  return ::capnp::_::PointerHelpers< ::cereal::LiveTrackingResponseCertificate>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
#if !CAPNP_LITE
inline  ::cereal::LiveTrackingResponseCertificate::Pipeline LiveTrackingResponseWitness::Pipeline::getCertificate() {
  return  ::cereal::LiveTrackingResponseCertificate::Pipeline(_typeless.getPointerField(0));
}
#endif  // !CAPNP_LITE
inline void LiveTrackingResponseWitness::Builder::setCertificate( ::cereal::LiveTrackingResponseCertificate::Reader value) {
  ::capnp::_::PointerHelpers< ::cereal::LiveTrackingResponseCertificate>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline  ::cereal::LiveTrackingResponseCertificate::Builder LiveTrackingResponseWitness::Builder::initCertificate() {
  return ::capnp::_::PointerHelpers< ::cereal::LiveTrackingResponseCertificate>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void LiveTrackingResponseWitness::Builder::adoptCertificate(
    ::capnp::Orphan< ::cereal::LiveTrackingResponseCertificate>&& value) {
  ::capnp::_::PointerHelpers< ::cereal::LiveTrackingResponseCertificate>::adopt(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::cereal::LiveTrackingResponseCertificate> LiveTrackingResponseWitness::Builder::disownCertificate() {
  return ::capnp::_::PointerHelpers< ::cereal::LiveTrackingResponseCertificate>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline  ::uint64_t LiveTrackingResponseWitness::Reader::getLastControlMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t LiveTrackingResponseWitness::Builder::getLastControlMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void LiveTrackingResponseWitness::Builder::setLastControlMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t LiveTrackingResponseWitness::Reader::getLastApplyMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t LiveTrackingResponseWitness::Builder::getLastApplyMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void LiveTrackingResponseWitness::Builder::setLastApplyMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t LiveTrackingResponseWitness::Reader::getLastPoseMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t LiveTrackingResponseWitness::Builder::getLastPoseMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void LiveTrackingResponseWitness::Builder::setLastPoseMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t LiveTrackingResponseWitness::Reader::getWindowStartMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t LiveTrackingResponseWitness::Builder::getWindowStartMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}
inline void LiveTrackingResponseWitness::Builder::setWindowStartMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS, value);
}

inline  ::uint16_t LiveTrackingResponseWitness::Reader::getIndependentPoses() const {
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS);
}

inline  ::uint16_t LiveTrackingResponseWitness::Builder::getIndependentPoses() {
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS);
}
inline void LiveTrackingResponseWitness::Builder::setIndependentPoses( ::uint16_t value) {
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS, value);
}

inline double LiveTrackingResponseWitness::Reader::getResidualRmse() const {
  return _reader.getDataField<double>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}

inline double LiveTrackingResponseWitness::Builder::getResidualRmse() {
  return _builder.getDataField<double>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}
inline void LiveTrackingResponseWitness::Builder::setResidualRmse(double value) {
  _builder.setDataField<double>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS, value);
}

inline  ::uint64_t LiveTrackingResponseWitness::Reader::getValidUntilMonoTime() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS);
}

inline  ::uint64_t LiveTrackingResponseWitness::Builder::getValidUntilMonoTime() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS);
}
inline void LiveTrackingResponseWitness::Builder::setValidUntilMonoTime( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS, value);
}

}  // namespace

CAPNP_END_HEADER