// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: stp_api.proto

#ifndef PROTOBUF_stp_5fapi_2eproto__INCLUDED
#define PROTOBUF_stp_5fapi_2eproto__INCLUDED

#include <string>

#include <google/protobuf/stubs/common.h>

#if GOOGLE_PROTOBUF_VERSION < 2005000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers.  Please update
#error your headers.
#endif
#if 2005000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers.  Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/message_lite.h>
#include <google/protobuf/repeated_field.h>
#include <google/protobuf/extension_set.h>
// @@protoc_insertion_point(includes)

namespace Impinj {
namespace STP {

// Internal implementation detail -- do not call these.
void  protobuf_AddDesc_stp_5fapi_2eproto();
void protobuf_AssignDesc_stp_5fapi_2eproto();
void protobuf_ShutdownFile_stp_5fapi_2eproto();

class Reply;
class DeviceState;
class Version;
class Versions;
class HandShake;
class Region;
class Timestamp;
class ConnectCommand;
class GetDeviceStateCommand;
class GetVersionsReaderCommand;
class StopCommand;
class ConnectResp;
class GetDeviceStateResp;
class GetVersionsReaderResp;
class InvalidResp;
class StopResp;
class DeviceConfig;
class TriggerConfig;
class StartTriggerConfig;
class StopTriggerConfig;
class GPIConfig;
class GPOConfig;
class STPDevice;
class OperationResponsibility;
class VoidTagResponsibility;
class OperationSummaryReportConfig;
class TagOperationReportConfig;
class ReportConfig;
class AntennaConfig;
class AntennasConfig;
class InventoryJob;
class CartonContentsJob;
class VoidTagConfig;
class Filter;
class SerializationJobFilters;
class SerializationJob;
class PCWord;
class EPCMemory;
class TIDMemory;
class Serialization;
class MonzaSelfSerialization;
class SerialNumberRange;
class UserMemory;
class Password;
class LockConfig;
class BlockPermalockConfig;
class MonzaR6PFeatureConfig;
class MonzaS6CFeatureConfig;
class MonzaR6FeatureConfig;
class MonzaR6AFeatureConfig;
class TIDTableEntry;
class TIDTableEntries;
class OrderedListEntry;
class OrderedListEntries;
class LowEncodeVolumeEventConfig;
class DeviceEventConfig;
class OperationSummaryReport;
class TagOperationReport;
class CartonContentsTag;
class CartonContentsReport;
class CartonContentsError;
class TagModeMetrics;
class TagMetrics;
class InterDeviceCommunicationMetrics;
class OperationMetrics;
class OperationDataDetails;
class OperationData;
class LicenseKey;
class OperationEvent;
class DeviceExceptionEvent;
class GPIEvent;
class LowEncodeVolumeEvent;
class DeviceEventReport;
class GetAntennaConfigCommand;
class SetAntennaConfigCommand;
class StartCommand;
class SetDeviceConfigCommand;
class GetDeviceConfigCommand;
class EngageCommand;
class DisengageCommand;
class SetOperationResultGPOCommand;
class AddSerializationJobCommand;
class RemoveSerializationJobCommand;
class SetInventoryJobCommand;
class SetCartonContentsJobCommand;
class GetOperationDataCommand;
class AddLicenseKeyCommand;
class AddTIDTableEntriesCommand;
class AddOrderedListEntriesCommand;
class StartResp;
class SetDeviceConfigResp;
class GetDeviceConfigResp;
class SetAntennaConfigResp;
class GetAntennaConfigResp;
class EngageResp;
class DisengageResp;
class SetOperationResultGPOResp;
class AddSerializationJobResp;
class RemoveSerializationJobResp;
class SetInventoryJobResp;
class SetCartonContentsJobResp;
class GetOperationDataResp;
class AddLicenseKeyResp;
class AddTIDTableEntriesResp;
class AddOrderedListEntriesResp;
class Command;
class Response;
class Report;
class Update;
class Packet;

enum ErrorCode {
  ERROR_CODE_SUCCESS = 0,
  ERROR_CODE_INVALID_COMMAND = 1,
  ERROR_CODE_INVALID_SET_KEY = 2,
  ERROR_CODE_INVALID_GET_KEY = 3,
  ERROR_CODE_INVALID_ADDRESS = 4,
  ERROR_CODE_INVALID_VALUE = 5,
  ERROR_CODE_FIRMWARE_INVALID = 6,
  ERROR_CODE_COMMAND_REFUSED = 7,
  ERROR_CODE_SET_KEY_READ_ONLY = 8,
  ERROR_CODE_NO_HANDSHAKE = 9,
  ERROR_CODE_NO_DEVICE_CONNECTION = 10,
  ERROR_CODE_UNSUPPORTED = 11,
  ERROR_CODE_NETWORK_INIT = 12
};
bool ErrorCode_IsValid(int value);
const ErrorCode ErrorCode_MIN = ERROR_CODE_SUCCESS;
const ErrorCode ErrorCode_MAX = ERROR_CODE_NETWORK_INIT;
const int ErrorCode_ARRAYSIZE = ErrorCode_MAX + 1;

enum Gen2Session {
  GEN2_SESSION_0 = 0,
  GEN2_SESSION_1 = 1,
  GEN2_SESSION_2 = 2,
  GEN2_SESSION_3 = 3
};
bool Gen2Session_IsValid(int value);
const Gen2Session Gen2Session_MIN = GEN2_SESSION_0;
const Gen2Session Gen2Session_MAX = GEN2_SESSION_3;
const int Gen2Session_ARRAYSIZE = Gen2Session_MAX + 1;

enum DeviceOperatingState {
  DEVICE_OPERATING_STATE_READY = 0,
  DEVICE_OPERATING_STATE_OPERATING = 1,
  DEVICE_OPERATING_STATE_ENGAGED = 2,
  DEVICE_OPERATING_STATE_FAULT = 3
};
bool DeviceOperatingState_IsValid(int value);
const DeviceOperatingState DeviceOperatingState_MIN = DEVICE_OPERATING_STATE_READY;
const DeviceOperatingState DeviceOperatingState_MAX = DEVICE_OPERATING_STATE_FAULT;
const int DeviceOperatingState_ARRAYSIZE = DeviceOperatingState_MAX + 1;

enum DeviceFaultType {
  DEVICE_FAULT_TYPE_NONE = 0,
  DEVICE_FAULT_TYPE_NETWORK_DISCONNECT = 1,
  DEVICE_FAULT_TYPE_APPLICATION_FAILURE = 2,
  DEVICE_FAULT_TYPE_FPGA_FAILURE = 3
};
bool DeviceFaultType_IsValid(int value);
const DeviceFaultType DeviceFaultType_MIN = DEVICE_FAULT_TYPE_NONE;
const DeviceFaultType DeviceFaultType_MAX = DEVICE_FAULT_TYPE_FPGA_FAILURE;
const int DeviceFaultType_ARRAYSIZE = DeviceFaultType_MAX + 1;

enum VersionType {
  VERSION_TYPE_KODIAK_HOST = 0,
  VERSION_TYPE_KODIAK_READER = 1,
  VERSION_TYPE_FRAME_READER = 2,
  VERSION_TYPE_API_HOST = 3,
  VERSION_TYPE_API_READER = 4,
  VERSION_TYPE_FIRMWARE = 5,
  VERSION_TYPE_FIRMWARE_CUST = 6,
  VERSION_TYPE_UPGRADE_AGENT = 7,
  VERSION_TYPE_FPGA_IMAGE = 8
};
bool VersionType_IsValid(int value);
const VersionType VersionType_MIN = VERSION_TYPE_KODIAK_HOST;
const VersionType VersionType_MAX = VERSION_TYPE_FPGA_IMAGE;
const int VersionType_ARRAYSIZE = VersionType_MAX + 1;

enum RegulatoryRegion {
  REGULATORY_REGION_FCC_PART_15_247 = 0,
  REGULATORY_REGION_ETSI_EN_300_220 = 1,
  REGULATORY_REGION_ETSI_EN_302_208_LBT = 2,
  REGULATORY_REGION_HONG_KONG_920_925_MHZ = 3,
  REGULATORY_REGION_TAIWAN_922_928_MHZ = 4,
  REGULATORY_REGION_JAPAN_952_954_MHZ = 5,
  REGULATORY_REGION_JAPAN_952_954_MHZ_LOWPOWER = 6,
  REGULATORY_REGION_ETSI_EN_302_208_V1_2_1 = 7,
  REGULATORY_REGION_KOREA_917_921_MHZ = 8,
  REGULATORY_REGION_MALAYSIA_919_921_MHZ = 9,
  REGULATORY_REGION_CHINA_920_925_MHZ = 10,
  REGULATORY_REGION_JAPAN_952_956_MHZ_NO_LBT = 11,
  REGULATORY_REGION_SOUTH_AFRICA_915_919_MHZ = 12,
  REGULATORY_REGION_BRAZIL_902_907_AND_915_928_MHZ = 13,
  REGULATORY_REGION_THAILAND_920_925_MHZ = 14,
  REGULATORY_REGION_SINGAPORE_920_925_MHZ = 15,
  REGULATORY_REGION_AUSTRALIA_920_926_MHZ = 16,
  REGULATORY_REGION_INDIA_865_867_MHZ = 17,
  REGULATORY_REGION_URUGUAY_916_928_MHZ = 18,
  REGULATORY_REGION_VIETNAM_920_925_MHZ = 19,
  REGULATORY_REGION_ISRAEL_915_917_MHZ = 20,
  REGULATORY_REGION_PHILIPPINES_918_920_MHZ = 21,
  REGULATORY_REGION_INDONESIA_923_925_MHZ = 22,
  REGULATORY_REGION_NEW_ZEALAND_921P5_928_MHZ = 23,
  REGULATORY_REGION_JAPAN_916_921_MHZ_NO_LBT = 24,
  REGULATORY_REGION_LATIN_AMERICA_902_928_MHZ = 25
};
bool RegulatoryRegion_IsValid(int value);
const RegulatoryRegion RegulatoryRegion_MIN = REGULATORY_REGION_FCC_PART_15_247;
const RegulatoryRegion RegulatoryRegion_MAX = REGULATORY_REGION_LATIN_AMERICA_902_928_MHZ;
const int RegulatoryRegion_ARRAYSIZE = RegulatoryRegion_MAX + 1;

enum GPIOState {
  GPIO_STATE_LOW = 0,
  GPIO_STATE_HIGH = 1
};
bool GPIOState_IsValid(int value);
const GPIOState GPIOState_MIN = GPIO_STATE_LOW;
const GPIOState GPIOState_MAX = GPIO_STATE_HIGH;
const int GPIOState_ARRAYSIZE = GPIOState_MAX + 1;

enum GPIOPolarity {
  GPIO_POLARITY_ACTIVE_LOW = 0,
  GPIO_POLARITY_ACTIVE_HIGH = 1
};
bool GPIOPolarity_IsValid(int value);
const GPIOPolarity GPIOPolarity_MIN = GPIO_POLARITY_ACTIVE_LOW;
const GPIOPolarity GPIOPolarity_MAX = GPIO_POLARITY_ACTIVE_HIGH;
const int GPIOPolarity_ARRAYSIZE = GPIOPolarity_MAX + 1;

enum Gen2Mode {
  GEN2_MODE_MAX_THROUGHPUT = 0,
  GEN2_MODE_HYBRID = 1,
  GEN2_MODE_DENSE_READER_M4 = 2,
  GEN2_MODE_DENSE_READER_M8 = 3,
  GEN2_MODE_MAX_MILLER = 4,
  GEN2_MODE_DENSE_READER_M4_2 = 5,
  GEN2_MODE_MAX_THROUGHPUT_M4 = 6,
  GEN2_MODE_AUTO_SET = 1000
};
bool Gen2Mode_IsValid(int value);
const Gen2Mode Gen2Mode_MIN = GEN2_MODE_MAX_THROUGHPUT;
const Gen2Mode Gen2Mode_MAX = GEN2_MODE_AUTO_SET;
const int Gen2Mode_ARRAYSIZE = Gen2Mode_MAX + 1;

enum InventorySearchMode {
  INVENTORY_SEARCH_MODE_DUAL_TARGET = 1,
  INVENTORY_SEARCH_MODE_SINGLE_TARGET_A_TO_B = 2,
  INVENTORY_SEARCH_MODE_SINGLE_TARGET_B_TO_A = 3,
  INVENTORY_SEARCH_MODE_SINGLE_TARGET_A_TO_B_MONZA_TAGFOCUS = 4,
  INVENTORY_SEARCH_MODE_SINGLE_TARGET_B_TO_A_MONZA_TAGFOCUS = 5,
  INVENTORY_SEARCH_MODE_CARTON_STAGE_1 = 7,
  INVENTORY_SEARCH_MODE_CARTON_STAGE_2 = 8
};
bool InventorySearchMode_IsValid(int value);
const InventorySearchMode InventorySearchMode_MIN = INVENTORY_SEARCH_MODE_DUAL_TARGET;
const InventorySearchMode InventorySearchMode_MAX = INVENTORY_SEARCH_MODE_CARTON_STAGE_2;
const int InventorySearchMode_ARRAYSIZE = InventorySearchMode_MAX + 1;

enum DeviceMode {
  DEVICE_MODE_INVENTORY = 0,
  DEVICE_MODE_ENCODE = 1,
  DEVICE_MODE_VERIFY_TAGCHIP_BASIC = 2,
  DEVICE_MODE_VERIFY_TAGCHIP_DATA = 3,
  DEVICE_MODE_ITEM_VERIFY = 6
};
bool DeviceMode_IsValid(int value);
const DeviceMode DeviceMode_MIN = DEVICE_MODE_INVENTORY;
const DeviceMode DeviceMode_MAX = DEVICE_MODE_ITEM_VERIFY;
const int DeviceMode_ARRAYSIZE = DeviceMode_MAX + 1;

enum OperationMode {
  OPERATION_MODE_BATCH = 0,
  OPERATION_MODE_SINGLE = 1,
  OPERATION_MODE_CONTINUOUS = 2
};
bool OperationMode_IsValid(int value);
const OperationMode OperationMode_MIN = OPERATION_MODE_BATCH;
const OperationMode OperationMode_MAX = OPERATION_MODE_CONTINUOUS;
const int OperationMode_ARRAYSIZE = OperationMode_MAX + 1;

enum GPIOSignalMode {
  GPIO_SIGNAL_MODE_COMBINED = 0,
  GPIO_SIGNAL_MODE_SEPARATE = 1,
  GPIO_SIGNAL_MODE_PRESENCE_DETECTION = 2
};
bool GPIOSignalMode_IsValid(int value);
const GPIOSignalMode GPIOSignalMode_MIN = GPIO_SIGNAL_MODE_COMBINED;
const GPIOSignalMode GPIOSignalMode_MAX = GPIO_SIGNAL_MODE_PRESENCE_DETECTION;
const int GPIOSignalMode_ARRAYSIZE = GPIOSignalMode_MAX + 1;

enum ReportType {
  REPORT_TYPE_ALL = 0,
  REPORT_TYPE_DEVICE_EVENT = 1,
  REPORT_TYPE_OPERATION_SUMMARY = 2,
  REPORT_TYPE_TAG_OPERATION = 3,
  REPORT_TYPE_CARTON_CONTENTS = 4
};
bool ReportType_IsValid(int value);
const ReportType ReportType_MIN = REPORT_TYPE_ALL;
const ReportType ReportType_MAX = REPORT_TYPE_CARTON_CONTENTS;
const int ReportType_ARRAYSIZE = ReportType_MAX + 1;

enum TagOperationReportTrigger {
  TAG_OPERATION_REPORT_TRIGGER_IMMEDIATE = 1
};
bool TagOperationReportTrigger_IsValid(int value);
const TagOperationReportTrigger TagOperationReportTrigger_MIN = TAG_OPERATION_REPORT_TRIGGER_IMMEDIATE;
const TagOperationReportTrigger TagOperationReportTrigger_MAX = TAG_OPERATION_REPORT_TRIGGER_IMMEDIATE;
const int TagOperationReportTrigger_ARRAYSIZE = TagOperationReportTrigger_MAX + 1;

enum OperationSummaryResult {
  OPERATION_SUMMARY_RESULT_PASS = 0,
  OPERATION_SUMMARY_RESULT_FAIL = 1
};
bool OperationSummaryResult_IsValid(int value);
const OperationSummaryResult OperationSummaryResult_MIN = OPERATION_SUMMARY_RESULT_PASS;
const OperationSummaryResult OperationSummaryResult_MAX = OPERATION_SUMMARY_RESULT_FAIL;
const int OperationSummaryResult_ARRAYSIZE = OperationSummaryResult_MAX + 1;

enum TagOperationResult {
  TAG_OPERATION_RESULT_PASS = 0,
  TAG_OPERATION_RESULT_PASS_ALREADY_DONE = 1,
  TAG_OPERATION_RESULT_RETRY = 2,
  TAG_OPERATION_RESULT_RETRY_INSUFFICIENT_POWER = 3,
  TAG_OPERATION_RESULT_RETRY_NO_RESPONSE_FROM_TAG = 4,
  TAG_OPERATION_RESULT_RETRY_SERIALIZATION_JOB_QUEUE_EMPTY = 5,
  TAG_OPERATION_RESULT_RETRY_TID_TABLE_NO_MATCH = 6,
  TAG_OPERATION_RESULT_RETRY_ORDERED_LIST_EMPTY = 7,
  TAG_OPERATION_RESULT_FAIL = 8,
  TAG_OPERATION_RESULT_FAIL_INSUFFICIENT_POWER = 9,
  TAG_OPERATION_RESULT_FAIL_NO_RESPONSE_FROM_TAG = 10,
  TAG_OPERATION_RESULT_FAIL_MEMORY_BANK_LOCKED = 11,
  TAG_OPERATION_RESULT_FAIL_MEMORY_BANK_MEMORY_OVERRUN = 12,
  TAG_OPERATION_RESULT_FAIL_GEN2_INSUFFICIENT_PRIVILEGES = 13,
  TAG_OPERATION_RESULT_FAIL_SERIALIZATION_JOB_QUEUE_EMPTY = 14,
  TAG_OPERATION_RESULT_FAIL_TID_TABLE_NO_MATCH = 15,
  TAG_OPERATION_RESULT_FAIL_ORDERED_LIST_EMPTY = 16,
  TAG_OPERATION_RESULT_FAIL_TAG_CHIP_NOT_SUPPORTED = 17,
  TAG_OPERATION_RESULT_FAIL_TAG_CHIP_SUPPORTED_LICENSE_KEY_NOT_INSTALLED = 18,
  TAG_OPERATION_RESULT_FAIL_TAG_NOT_INVENTORIED = 19,
  TAG_OPERATION_RESULT_FAIL_VOLUME_EXHAUSTED = 20,
  TAG_OPERATION_RESULT_FAIL_TID_PARITY_CHECK = 21,
  TAG_OPERATION_RESULT_FAIL_SERIAL_NUMBER_RANGE_EMPTY = 22,
  TAG_OPERATION_RESULT_FAIL_VOYANTIC_TEST_RESULT_MISSING = 23,
  TAG_OPERATION_RESULT_FAIL_VOYANTIC_TEST_RESULT_FAILED = 24,
  TAG_OPERATION_RESULT_VOID_TAG_PASS = 25,
  TAG_OPERATION_RESULT_VOID_TAG_FAIL = 26,
  TAG_OPERATION_RESULT_FAIL_TID_TABLE_INVALID_CONFIG = 27,
  TAG_OPERATION_RESULT_FAIL_FILTER_NO_MATCH = 28,
  TAG_OPERATION_RESULT_FAIL_VOLUME_LICENSE_REVOKED = 29,
  TAG_OPERATION_RESULT_FAIL_INVENTORIED_EPC_MISMATCH = 30,
  TAG_OPERATION_RESULT_FAIL_CANNOT_CHANGE_MEMORY_MAP_CONFIG = 31
};
bool TagOperationResult_IsValid(int value);
const TagOperationResult TagOperationResult_MIN = TAG_OPERATION_RESULT_PASS;
const TagOperationResult TagOperationResult_MAX = TAG_OPERATION_RESULT_FAIL_CANNOT_CHANGE_MEMORY_MAP_CONFIG;
const int TagOperationResult_ARRAYSIZE = TagOperationResult_MAX + 1;

enum SerializationJobType {
  SERIALIZATION_JOB_TYPE_STATIC = 1,
  SERIALIZATION_JOB_TYPE_TID_TABLE = 4,
  SERIALIZATION_JOB_TYPE_ORDERED_LIST = 5
};
bool SerializationJobType_IsValid(int value);
const SerializationJobType SerializationJobType_MIN = SERIALIZATION_JOB_TYPE_STATIC;
const SerializationJobType SerializationJobType_MAX = SERIALIZATION_JOB_TYPE_ORDERED_LIST;
const int SerializationJobType_ARRAYSIZE = SerializationJobType_MAX + 1;

enum SerializationJobCompletionCriteria {
  SERIALIZATION_JOB_COMPLETION_CRITERIA_NONE = 4
};
bool SerializationJobCompletionCriteria_IsValid(int value);
const SerializationJobCompletionCriteria SerializationJobCompletionCriteria_MIN = SERIALIZATION_JOB_COMPLETION_CRITERIA_NONE;
const SerializationJobCompletionCriteria SerializationJobCompletionCriteria_MAX = SERIALIZATION_JOB_COMPLETION_CRITERIA_NONE;
const int SerializationJobCompletionCriteria_ARRAYSIZE = SerializationJobCompletionCriteria_MAX + 1;

enum SerialNumberRangeFormat {
  SERIAL_NUMBER_RANGE_FORMAT_HEX = 0,
  SERIAL_NUMBER_RANGE_FORMAT_DEC = 1
};
bool SerialNumberRangeFormat_IsValid(int value);
const SerialNumberRangeFormat SerialNumberRangeFormat_MIN = SERIAL_NUMBER_RANGE_FORMAT_HEX;
const SerialNumberRangeFormat SerialNumberRangeFormat_MAX = SERIAL_NUMBER_RANGE_FORMAT_DEC;
const int SerialNumberRangeFormat_ARRAYSIZE = SerialNumberRangeFormat_MAX + 1;

enum PasswordGenerationMethod {
  PASSWORD_GENERATION_METHOD_STATIC = 1
};
bool PasswordGenerationMethod_IsValid(int value);
const PasswordGenerationMethod PasswordGenerationMethod_MIN = PASSWORD_GENERATION_METHOD_STATIC;
const PasswordGenerationMethod PasswordGenerationMethod_MAX = PASSWORD_GENERATION_METHOD_STATIC;
const int PasswordGenerationMethod_ARRAYSIZE = PasswordGenerationMethod_MAX + 1;

enum MonzaR6PMemoryMapConfig {
  MONZA_R6P_MEMORY_MAP_CONFIG_96_BIT_EPC_64_BIT_USER = 0,
  MONZA_R6P_MEMORY_MAP_CONFIG_128_BIT_EPC_32_BIT_USER = 1
};
bool MonzaR6PMemoryMapConfig_IsValid(int value);
const MonzaR6PMemoryMapConfig MonzaR6PMemoryMapConfig_MIN = MONZA_R6P_MEMORY_MAP_CONFIG_96_BIT_EPC_64_BIT_USER;
const MonzaR6PMemoryMapConfig MonzaR6PMemoryMapConfig_MAX = MONZA_R6P_MEMORY_MAP_CONFIG_128_BIT_EPC_32_BIT_USER;
const int MonzaR6PMemoryMapConfig_ARRAYSIZE = MonzaR6PMemoryMapConfig_MAX + 1;

enum TagOperationReportType {
  TAG_OPERATION_REPORT_TYPE_INVENTORY = 0,
  TAG_OPERATION_REPORT_TYPE_VERIFY = 1,
  TAG_OPERATION_REPORT_TYPE_ENCODE = 2
};
bool TagOperationReportType_IsValid(int value);
const TagOperationReportType TagOperationReportType_MIN = TAG_OPERATION_REPORT_TYPE_INVENTORY;
const TagOperationReportType TagOperationReportType_MAX = TAG_OPERATION_REPORT_TYPE_ENCODE;
const int TagOperationReportType_ARRAYSIZE = TagOperationReportType_MAX + 1;

enum CartonContentsResult {
  CARTON_CONTENTS_RESULT_OK = 1,
  CARTON_CONTENTS_RESULT_ERROR_NO_ENTER = 3,
  CARTON_CONTENTS_RESULT_ERROR_NO_START = 2
};
bool CartonContentsResult_IsValid(int value);
const CartonContentsResult CartonContentsResult_MIN = CARTON_CONTENTS_RESULT_OK;
const CartonContentsResult CartonContentsResult_MAX = CARTON_CONTENTS_RESULT_ERROR_NO_ENTER;
const int CartonContentsResult_ARRAYSIZE = CartonContentsResult_MAX + 1;

enum CartonContentsErrorType {
  CARTON_CONTENTS_ERROR_EXTRA_LEADING_ENTER = 1,
  CARTON_CONTENTS_ERROR_EXTRA_TRAILING_ENTER = 2,
  CARTON_CONTENTS_ERROR_MISSING_LEADING_ENTER = 3,
  CARTON_CONTENTS_ERROR_MISSING_TRAILING_ENTER = 4
};
bool CartonContentsErrorType_IsValid(int value);
const CartonContentsErrorType CartonContentsErrorType_MIN = CARTON_CONTENTS_ERROR_EXTRA_LEADING_ENTER;
const CartonContentsErrorType CartonContentsErrorType_MAX = CARTON_CONTENTS_ERROR_MISSING_TRAILING_ENTER;
const int CartonContentsErrorType_ARRAYSIZE = CartonContentsErrorType_MAX + 1;

enum OperationEventType {
  OPERATION_EVENT_TYPE_START_TRIGGER = 1,
  OPERATION_EVENT_TYPE_STOP_TRIGGER = 2,
  OPERATION_EVENT_TYPE_COMPLETE = 3
};
bool OperationEventType_IsValid(int value);
const OperationEventType OperationEventType_MIN = OPERATION_EVENT_TYPE_START_TRIGGER;
const OperationEventType OperationEventType_MAX = OPERATION_EVENT_TYPE_COMPLETE;
const int OperationEventType_ARRAYSIZE = OperationEventType_MAX + 1;

enum OperationTriggerType {
  OPERATION_TRIGGER_TYPE_CLIENT = 1,
  OPERATION_TRIGGER_TYPE_GPI = 2,
  OPERATION_TRIGGER_TYPE_TIMEOUT = 4
};
bool OperationTriggerType_IsValid(int value);
const OperationTriggerType OperationTriggerType_MIN = OPERATION_TRIGGER_TYPE_CLIENT;
const OperationTriggerType OperationTriggerType_MAX = OPERATION_TRIGGER_TYPE_TIMEOUT;
const int OperationTriggerType_ARRAYSIZE = OperationTriggerType_MAX + 1;

enum DeviceExceptionEventType {
  DEVICE_EXCEPTION_EVENT_TYPE_UNKNOWN = 1,
  DEVICE_EXCEPTION_EVENT_TYPE_SYSTEM_FAULT = 2,
  DEVICE_EXCEPTION_EVENT_TYPE_OPERATION_START_TRIGGER_FAULT = 3
};
bool DeviceExceptionEventType_IsValid(int value);
const DeviceExceptionEventType DeviceExceptionEventType_MIN = DEVICE_EXCEPTION_EVENT_TYPE_UNKNOWN;
const DeviceExceptionEventType DeviceExceptionEventType_MAX = DEVICE_EXCEPTION_EVENT_TYPE_OPERATION_START_TRIGGER_FAULT;
const int DeviceExceptionEventType_ARRAYSIZE = DeviceExceptionEventType_MAX + 1;

enum LowEncodeVolumeEventType {
  LOW_ENCODE_VOLUME_EVENT_MONZA = 1,
  LOW_ENCODE_VOLUME_EVENT_NON_MONZA = 2
};
bool LowEncodeVolumeEventType_IsValid(int value);
const LowEncodeVolumeEventType LowEncodeVolumeEventType_MIN = LOW_ENCODE_VOLUME_EVENT_MONZA;
const LowEncodeVolumeEventType LowEncodeVolumeEventType_MAX = LOW_ENCODE_VOLUME_EVENT_NON_MONZA;
const int LowEncodeVolumeEventType_ARRAYSIZE = LowEncodeVolumeEventType_MAX + 1;

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

class Reply : public ::google::protobuf::MessageLite {
 public:
  Reply();
  virtual ~Reply();

  Reply(const Reply& from);

  inline Reply& operator=(const Reply& from) {
    CopyFrom(from);
    return *this;
  }

  static const Reply& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const Reply* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(Reply* other);

  // implements Message ----------------------------------------------

  Reply* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const Reply& from);
  void MergeFrom(const Reply& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // required .Impinj.STP.ErrorCode error_code = 1;
  inline bool has_error_code() const;
  inline void clear_error_code();
  static const int kErrorCodeFieldNumber = 1;
  inline ::Impinj::STP::ErrorCode error_code() const;
  inline void set_error_code(::Impinj::STP::ErrorCode value);

  // optional string error_string = 2;
  inline bool has_error_string() const;
  inline void clear_error_string();
  static const int kErrorStringFieldNumber = 2;
  inline const ::std::string& error_string() const;
  inline void set_error_string(const ::std::string& value);
  inline void set_error_string(const char* value);
  inline void set_error_string(const char* value, size_t size);
  inline ::std::string* mutable_error_string();
  inline ::std::string* release_error_string();
  inline void set_allocated_error_string(::std::string* error_string);

  // @@protoc_insertion_point(class_scope:Impinj.STP.Reply)
 private:
  inline void set_has_error_code();
  inline void clear_has_error_code();
  inline void set_has_error_string();
  inline void clear_has_error_string();

  ::std::string* error_string_;
  int error_code_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static Reply* default_instance_;
};
// -------------------------------------------------------------------

class DeviceState : public ::google::protobuf::MessageLite {
 public:
  DeviceState();
  virtual ~DeviceState();

  DeviceState(const DeviceState& from);

  inline DeviceState& operator=(const DeviceState& from) {
    CopyFrom(from);
    return *this;
  }

  static const DeviceState& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const DeviceState* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(DeviceState* other);

  // implements Message ----------------------------------------------

  DeviceState* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const DeviceState& from);
  void MergeFrom(const DeviceState& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .Impinj.STP.DeviceOperatingState device_operating_state = 1;
  inline bool has_device_operating_state() const;
  inline void clear_device_operating_state();
  static const int kDeviceOperatingStateFieldNumber = 1;
  inline ::Impinj::STP::DeviceOperatingState device_operating_state() const;
  inline void set_device_operating_state(::Impinj::STP::DeviceOperatingState value);

  // optional .Impinj.STP.DeviceFaultType device_fault = 2;
  inline bool has_device_fault() const;
  inline void clear_device_fault();
  static const int kDeviceFaultFieldNumber = 2;
  inline ::Impinj::STP::DeviceFaultType device_fault() const;
  inline void set_device_fault(::Impinj::STP::DeviceFaultType value);

  // optional string fault_details = 3;
  inline bool has_fault_details() const;
  inline void clear_fault_details();
  static const int kFaultDetailsFieldNumber = 3;
  inline const ::std::string& fault_details() const;
  inline void set_fault_details(const ::std::string& value);
  inline void set_fault_details(const char* value);
  inline void set_fault_details(const char* value, size_t size);
  inline ::std::string* mutable_fault_details();
  inline ::std::string* release_fault_details();
  inline void set_allocated_fault_details(::std::string* fault_details);

  // @@protoc_insertion_point(class_scope:Impinj.STP.DeviceState)
 private:
  inline void set_has_device_operating_state();
  inline void clear_has_device_operating_state();
  inline void set_has_device_fault();
  inline void clear_has_device_fault();
  inline void set_has_fault_details();
  inline void clear_has_fault_details();

  int device_operating_state_;
  int device_fault_;
  ::std::string* fault_details_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static DeviceState* default_instance_;
};
// -------------------------------------------------------------------

class Version : public ::google::protobuf::MessageLite {
 public:
  Version();
  virtual ~Version();

  Version(const Version& from);

  inline Version& operator=(const Version& from) {
    CopyFrom(from);
    return *this;
  }

  static const Version& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const Version* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(Version* other);

  // implements Message ----------------------------------------------

  Version* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const Version& from);
  void MergeFrom(const Version& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // required .Impinj.STP.VersionType version_ID = 1;
  inline bool has_version_id() const;
  inline void clear_version_id();
  static const int kVersionIDFieldNumber = 1;
  inline ::Impinj::STP::VersionType version_id() const;
  inline void set_version_id(::Impinj::STP::VersionType value);

  // optional uint32 major = 2;
  inline bool has_major() const;
  inline void clear_major();
  static const int kMajorFieldNumber = 2;
  inline ::google::protobuf::uint32 major() const;
  inline void set_major(::google::protobuf::uint32 value);

  // optional uint32 minor = 3;
  inline bool has_minor() const;
  inline void clear_minor();
  static const int kMinorFieldNumber = 3;
  inline ::google::protobuf::uint32 minor() const;
  inline void set_minor(::google::protobuf::uint32 value);

  // optional uint32 maintenance = 4;
  inline bool has_maintenance() const;
  inline void clear_maintenance();
  static const int kMaintenanceFieldNumber = 4;
  inline ::google::protobuf::uint32 maintenance() const;
  inline void set_maintenance(::google::protobuf::uint32 value);

  // optional uint32 build = 5;
  inline bool has_build() const;
  inline void clear_build();
  static const int kBuildFieldNumber = 5;
  inline ::google::protobuf::uint32 build() const;
  inline void set_build(::google::protobuf::uint32 value);

  // optional string ident = 6;
  inline bool has_ident() const;
  inline void clear_ident();
  static const int kIdentFieldNumber = 6;
  inline const ::std::string& ident() const;
  inline void set_ident(const ::std::string& value);
  inline void set_ident(const char* value);
  inline void set_ident(const char* value, size_t size);
  inline ::std::string* mutable_ident();
  inline ::std::string* release_ident();
  inline void set_allocated_ident(::std::string* ident);

  // @@protoc_insertion_point(class_scope:Impinj.STP.Version)
 private:
  inline void set_has_version_id();
  inline void clear_has_version_id();
  inline void set_has_major();
  inline void clear_has_major();
  inline void set_has_minor();
  inline void clear_has_minor();
  inline void set_has_maintenance();
  inline void clear_has_maintenance();
  inline void set_has_build();
  inline void clear_has_build();
  inline void set_has_ident();
  inline void clear_has_ident();

  int version_id_;
  ::google::protobuf::uint32 major_;
  ::google::protobuf::uint32 minor_;
  ::google::protobuf::uint32 maintenance_;
  ::std::string* ident_;
  ::google::protobuf::uint32 build_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(6 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static Version* default_instance_;
};
// -------------------------------------------------------------------

class Versions : public ::google::protobuf::MessageLite {
 public:
  Versions();
  virtual ~Versions();

  Versions(const Versions& from);

  inline Versions& operator=(const Versions& from) {
    CopyFrom(from);
    return *this;
  }

  static const Versions& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const Versions* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(Versions* other);

  // implements Message ----------------------------------------------

  Versions* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const Versions& from);
  void MergeFrom(const Versions& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated .Impinj.STP.Version version_list = 1;
  inline int version_list_size() const;
  inline void clear_version_list();
  static const int kVersionListFieldNumber = 1;
  inline const ::Impinj::STP::Version& version_list(int index) const;
  inline ::Impinj::STP::Version* mutable_version_list(int index);
  inline ::Impinj::STP::Version* add_version_list();
  inline const ::google::protobuf::RepeatedPtrField< ::Impinj::STP::Version >&
      version_list() const;
  inline ::google::protobuf::RepeatedPtrField< ::Impinj::STP::Version >*
      mutable_version_list();

  // @@protoc_insertion_point(class_scope:Impinj.STP.Versions)
 private:

  ::google::protobuf::RepeatedPtrField< ::Impinj::STP::Version > version_list_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static Versions* default_instance_;
};
// -------------------------------------------------------------------

class HandShake : public ::google::protobuf::MessageLite {
 public:
  HandShake();
  virtual ~HandShake();

  HandShake(const HandShake& from);

  inline HandShake& operator=(const HandShake& from) {
    CopyFrom(from);
    return *this;
  }

  static const HandShake& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const HandShake* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(HandShake* other);

  // implements Message ----------------------------------------------

  HandShake* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const HandShake& from);
  void MergeFrom(const HandShake& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // required string API_name = 1;
  inline bool has_api_name() const;
  inline void clear_api_name();
  static const int kAPINameFieldNumber = 1;
  inline const ::std::string& api_name() const;
  inline void set_api_name(const ::std::string& value);
  inline void set_api_name(const char* value);
  inline void set_api_name(const char* value, size_t size);
  inline ::std::string* mutable_api_name();
  inline ::std::string* release_api_name();
  inline void set_allocated_api_name(::std::string* api_name);

  // required uint32 API_version = 2;
  inline bool has_api_version() const;
  inline void clear_api_version();
  static const int kAPIVersionFieldNumber = 2;
  inline ::google::protobuf::uint32 api_version() const;
  inline void set_api_version(::google::protobuf::uint32 value);

  // @@protoc_insertion_point(class_scope:Impinj.STP.HandShake)
 private:
  inline void set_has_api_name();
  inline void clear_has_api_name();
  inline void set_has_api_version();
  inline void clear_has_api_version();

  ::std::string* api_name_;
  ::google::protobuf::uint32 api_version_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static HandShake* default_instance_;
};
// -------------------------------------------------------------------

class Region : public ::google::protobuf::MessageLite {
 public:
  Region();
  virtual ~Region();

  Region(const Region& from);

  inline Region& operator=(const Region& from) {
    CopyFrom(from);
    return *this;
  }

  static const Region& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const Region* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(Region* other);

  // implements Message ----------------------------------------------

  Region* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const Region& from);
  void MergeFrom(const Region& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // required .Impinj.STP.RegulatoryRegion region_id = 1 [default = REGULATORY_REGION_FCC_PART_15_247];
  inline bool has_region_id() const;
  inline void clear_region_id();
  static const int kRegionIdFieldNumber = 1;
  inline ::Impinj::STP::RegulatoryRegion region_id() const;
  inline void set_region_id(::Impinj::STP::RegulatoryRegion value);

  // repeated uint32 fixed_frequency_list = 2;
  inline int fixed_frequency_list_size() const;
  inline void clear_fixed_frequency_list();
  static const int kFixedFrequencyListFieldNumber = 2;
  inline ::google::protobuf::uint32 fixed_frequency_list(int index) const;
  inline void set_fixed_frequency_list(int index, ::google::protobuf::uint32 value);
  inline void add_fixed_frequency_list(::google::protobuf::uint32 value);
  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
      fixed_frequency_list() const;
  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
      mutable_fixed_frequency_list();

  // @@protoc_insertion_point(class_scope:Impinj.STP.Region)
 private:
  inline void set_has_region_id();
  inline void clear_has_region_id();

  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > fixed_frequency_list_;
  int region_id_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static Region* default_instance_;
};
// -------------------------------------------------------------------

class Timestamp : public ::google::protobuf::MessageLite {
 public:
  Timestamp();
  virtual ~Timestamp();

  Timestamp(const Timestamp& from);

  inline Timestamp& operator=(const Timestamp& from) {
    CopyFrom(from);
    return *this;
  }

  static const Timestamp& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const Timestamp* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(Timestamp* other);

  // implements Message ----------------------------------------------

  Timestamp* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const Timestamp& from);
  void MergeFrom(const Timestamp& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional uint64 useconds_since_epoch = 1;
  inline bool has_useconds_since_epoch() const;
  inline void clear_useconds_since_epoch();
  static const int kUsecondsSinceEpochFieldNumber = 1;
  inline ::google::protobuf::uint64 useconds_since_epoch() const;
  inline void set_useconds_since_epoch(::google::protobuf::uint64 value);

  // @@protoc_insertion_point(class_scope:Impinj.STP.Timestamp)
 private:
  inline void set_has_useconds_since_epoch();
  inline void clear_has_useconds_since_epoch();

  ::google::protobuf::uint64 useconds_since_epoch_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static Timestamp* default_instance_;
};
// -------------------------------------------------------------------

class ConnectCommand : public ::google::protobuf::MessageLite {
 public:
  ConnectCommand();
  virtual ~ConnectCommand();

  ConnectCommand(const ConnectCommand& from);

  inline ConnectCommand& operator=(const ConnectCommand& from) {
    CopyFrom(from);
    return *this;
  }

  static const ConnectCommand& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const ConnectCommand* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(ConnectCommand* other);

  // implements Message ----------------------------------------------

  ConnectCommand* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const ConnectCommand& from);
  void MergeFrom(const ConnectCommand& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .Impinj.STP.HandShake hand_shake = 1;
  inline bool has_hand_shake() const;
  inline void clear_hand_shake();
  static const int kHandShakeFieldNumber = 1;
  inline const ::Impinj::STP::HandShake& hand_shake() const;
  inline ::Impinj::STP::HandShake* mutable_hand_shake();
  inline ::Impinj::STP::HandShake* release_hand_shake();
  inline void set_allocated_hand_shake(::Impinj::STP::HandShake* hand_shake);

  // @@protoc_insertion_point(class_scope:Impinj.STP.ConnectCommand)
 private:
  inline void set_has_hand_shake();
  inline void clear_has_hand_shake();

  ::Impinj::STP::HandShake* hand_shake_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static ConnectCommand* default_instance_;
};
// -------------------------------------------------------------------

class GetDeviceStateCommand : public ::google::protobuf::MessageLite {
 public:
  GetDeviceStateCommand();
  virtual ~GetDeviceStateCommand();

  GetDeviceStateCommand(const GetDeviceStateCommand& from);

  inline GetDeviceStateCommand& operator=(const GetDeviceStateCommand& from) {
    CopyFrom(from);
    return *this;
  }

  static const GetDeviceStateCommand& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const GetDeviceStateCommand* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(GetDeviceStateCommand* other);

  // implements Message ----------------------------------------------

  GetDeviceStateCommand* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const GetDeviceStateCommand& from);
  void MergeFrom(const GetDeviceStateCommand& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional bool reserved = 1;
  inline bool has_reserved() const;
  inline void clear_reserved();
  static const int kReservedFieldNumber = 1;
  inline bool reserved() const;
  inline void set_reserved(bool value);

  // @@protoc_insertion_point(class_scope:Impinj.STP.GetDeviceStateCommand)
 private:
  inline void set_has_reserved();
  inline void clear_has_reserved();

  bool reserved_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static GetDeviceStateCommand* default_instance_;
};
// -------------------------------------------------------------------

class GetVersionsReaderCommand : public ::google::protobuf::MessageLite {
 public:
  GetVersionsReaderCommand();
  virtual ~GetVersionsReaderCommand();

  GetVersionsReaderCommand(const GetVersionsReaderCommand& from);

  inline GetVersionsReaderCommand& operator=(const GetVersionsReaderCommand& from) {
    CopyFrom(from);
    return *this;
  }

  static const GetVersionsReaderCommand& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const GetVersionsReaderCommand* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(GetVersionsReaderCommand* other);

  // implements Message ----------------------------------------------

  GetVersionsReaderCommand* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const GetVersionsReaderCommand& from);
  void MergeFrom(const GetVersionsReaderCommand& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional bool reserved = 1;
  inline bool has_reserved() const;
  inline void clear_reserved();
  static const int kReservedFieldNumber = 1;
  inline bool reserved() const;
  inline void set_reserved(bool value);

  // @@protoc_insertion_point(class_scope:Impinj.STP.GetVersionsReaderCommand)
 private:
  inline void set_has_reserved();
  inline void clear_has_reserved();

  bool reserved_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static GetVersionsReaderCommand* default_instance_;
};
// -------------------------------------------------------------------

class StopCommand : public ::google::protobuf::MessageLite {
 public:
  StopCommand();
  virtual ~StopCommand();

  StopCommand(const StopCommand& from);

  inline StopCommand& operator=(const StopCommand& from) {
    CopyFrom(from);
    return *this;
  }

  static const StopCommand& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const StopCommand* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(StopCommand* other);

  // implements Message ----------------------------------------------

  StopCommand* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const StopCommand& from);
  void MergeFrom(const StopCommand& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional bool reserved = 1;
  inline bool has_reserved() const;
  inline void clear_reserved();
  static const int kReservedFieldNumber = 1;
  inline bool reserved() const;
  inline void set_reserved(bool value);

  // @@protoc_insertion_point(class_scope:Impinj.STP.StopCommand)
 private:
  inline void set_has_reserved();
  inline void clear_has_reserved();

  bool reserved_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static StopCommand* default_instance_;
};
// -------------------------------------------------------------------

class ConnectResp : public ::google::protobuf::MessageLite {
 public:
  ConnectResp();
  virtual ~ConnectResp();

  ConnectResp(const ConnectResp& from);

  inline ConnectResp& operator=(const ConnectResp& from) {
    CopyFrom(from);
    return *this;
  }

  static const ConnectResp& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const ConnectResp* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(ConnectResp* other);

  // implements Message ----------------------------------------------

  ConnectResp* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const ConnectResp& from);
  void MergeFrom(const ConnectResp& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .Impinj.STP.Reply reply = 1;
  inline bool has_reply() const;
  inline void clear_reply();
  static const int kReplyFieldNumber = 1;
  inline const ::Impinj::STP::Reply& reply() const;
  inline ::Impinj::STP::Reply* mutable_reply();
  inline ::Impinj::STP::Reply* release_reply();
  inline void set_allocated_reply(::Impinj::STP::Reply* reply);

  // optional .Impinj.STP.HandShake hand_shake = 2;
  inline bool has_hand_shake() const;
  inline void clear_hand_shake();
  static const int kHandShakeFieldNumber = 2;
  inline const ::Impinj::STP::HandShake& hand_shake() const;
  inline ::Impinj::STP::HandShake* mutable_hand_shake();
  inline ::Impinj::STP::HandShake* release_hand_shake();
  inline void set_allocated_hand_shake(::Impinj::STP::HandShake* hand_shake);

  // @@protoc_insertion_point(class_scope:Impinj.STP.ConnectResp)
 private:
  inline void set_has_reply();
  inline void clear_has_reply();
  inline void set_has_hand_shake();
  inline void clear_has_hand_shake();

  ::Impinj::STP::Reply* reply_;
  ::Impinj::STP::HandShake* hand_shake_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static ConnectResp* default_instance_;
};
// -------------------------------------------------------------------

class GetDeviceStateResp : public ::google::protobuf::MessageLite {
 public:
  GetDeviceStateResp();
  virtual ~GetDeviceStateResp();

  GetDeviceStateResp(const GetDeviceStateResp& from);

  inline GetDeviceStateResp& operator=(const GetDeviceStateResp& from) {
    CopyFrom(from);
    return *this;
  }

  static const GetDeviceStateResp& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const GetDeviceStateResp* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(GetDeviceStateResp* other);

  // implements Message ----------------------------------------------

  GetDeviceStateResp* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const GetDeviceStateResp& from);
  void MergeFrom(const GetDeviceStateResp& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .Impinj.STP.Reply reply = 1;
  inline bool has_reply() const;
  inline void clear_reply();
  static const int kReplyFieldNumber = 1;
  inline const ::Impinj::STP::Reply& reply() const;
  inline ::Impinj::STP::Reply* mutable_reply();
  inline ::Impinj::STP::Reply* release_reply();
  inline void set_allocated_reply(::Impinj::STP::Reply* reply);

  // optional .Impinj.STP.DeviceState device_state = 2;
  inline bool has_device_state() const;
  inline void clear_device_state();
  static const int kDeviceStateFieldNumber = 2;
  inline const ::Impinj::STP::DeviceState& device_state() const;
  inline ::Impinj::STP::DeviceState* mutable_device_state();
  inline ::Impinj::STP::DeviceState* release_device_state();
  inline void set_allocated_device_state(::Impinj::STP::DeviceState* device_state);

  // @@protoc_insertion_point(class_scope:Impinj.STP.GetDeviceStateResp)
 private:
  inline void set_has_reply();
  inline void clear_has_reply();
  inline void set_has_device_state();
  inline void clear_has_device_state();

  ::Impinj::STP::Reply* reply_;
  ::Impinj::STP::DeviceState* device_state_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static GetDeviceStateResp* default_instance_;
};
// -------------------------------------------------------------------

class GetVersionsReaderResp : public ::google::protobuf::MessageLite {
 public:
  GetVersionsReaderResp();
  virtual ~GetVersionsReaderResp();

  GetVersionsReaderResp(const GetVersionsReaderResp& from);

  inline GetVersionsReaderResp& operator=(const GetVersionsReaderResp& from) {
    CopyFrom(from);
    return *this;
  }

  static const GetVersionsReaderResp& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const GetVersionsReaderResp* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(GetVersionsReaderResp* other);

  // implements Message ----------------------------------------------

  GetVersionsReaderResp* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const GetVersionsReaderResp& from);
  void MergeFrom(const GetVersionsReaderResp& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .Impinj.STP.Reply reply = 1;
  inline bool has_reply() const;
  inline void clear_reply();
  static const int kReplyFieldNumber = 1;
  inline const ::Impinj::STP::Reply& reply() const;
  inline ::Impinj::STP::Reply* mutable_reply();
  inline ::Impinj::STP::Reply* release_reply();
  inline void set_allocated_reply(::Impinj::STP::Reply* reply);

  // optional .Impinj.STP.Versions versions = 2;
  inline bool has_versions() const;
  inline void clear_versions();
  static const int kVersionsFieldNumber = 2;
  inline const ::Impinj::STP::Versions& versions() const;
  inline ::Impinj::STP::Versions* mutable_versions();
  inline ::Impinj::STP::Versions* release_versions();
  inline void set_allocated_versions(::Impinj::STP::Versions* versions);

  // @@protoc_insertion_point(class_scope:Impinj.STP.GetVersionsReaderResp)
 private:
  inline void set_has_reply();
  inline void clear_has_reply();
  inline void set_has_versions();
  inline void clear_has_versions();

  ::Impinj::STP::Reply* reply_;
  ::Impinj::STP::Versions* versions_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static GetVersionsReaderResp* default_instance_;
};
// -------------------------------------------------------------------

class InvalidResp : public ::google::protobuf::MessageLite {
 public:
  InvalidResp();
  virtual ~InvalidResp();

  InvalidResp(const InvalidResp& from);

  inline InvalidResp& operator=(const InvalidResp& from) {
    CopyFrom(from);
    return *this;
  }

  static const InvalidResp& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const InvalidResp* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(InvalidResp* other);

  // implements Message ----------------------------------------------

  InvalidResp* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const InvalidResp& from);
  void MergeFrom(const InvalidResp& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional bool reserved = 1;
  inline bool has_reserved() const;
  inline void clear_reserved();
  static const int kReservedFieldNumber = 1;
  inline bool reserved() const;
  inline void set_reserved(bool value);

  // @@protoc_insertion_point(class_scope:Impinj.STP.InvalidResp)
 private:
  inline void set_has_reserved();
  inline void clear_has_reserved();

  bool reserved_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static InvalidResp* default_instance_;
};
// -------------------------------------------------------------------

class StopResp : public ::google::protobuf::MessageLite {
 public:
  StopResp();
  virtual ~StopResp();

  StopResp(const StopResp& from);

  inline StopResp& operator=(const StopResp& from) {
    CopyFrom(from);
    return *this;
  }

  static const StopResp& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const StopResp* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(StopResp* other);

  // implements Message ----------------------------------------------

  StopResp* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const StopResp& from);
  void MergeFrom(const StopResp& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .Impinj.STP.Reply reply = 1;
  inline bool has_reply() const;
  inline void clear_reply();
  static const int kReplyFieldNumber = 1;
  inline const ::Impinj::STP::Reply& reply() const;
  inline ::Impinj::STP::Reply* mutable_reply();
  inline ::Impinj::STP::Reply* release_reply();
  inline void set_allocated_reply(::Impinj::STP::Reply* reply);

  // @@protoc_insertion_point(class_scope:Impinj.STP.StopResp)
 private:
  inline void set_has_reply();
  inline void clear_has_reply();

  ::Impinj::STP::Reply* reply_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static StopResp* default_instance_;
};
// -------------------------------------------------------------------

class DeviceConfig : public ::google::protobuf::MessageLite {
 public:
  DeviceConfig();
  virtual ~DeviceConfig();

  DeviceConfig(const DeviceConfig& from);

  inline DeviceConfig& operator=(const DeviceConfig& from) {
    CopyFrom(from);
    return *this;
  }

  static const DeviceConfig& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const DeviceConfig* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(DeviceConfig* other);

  // implements Message ----------------------------------------------

  DeviceConfig* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const DeviceConfig& from);
  void MergeFrom(const DeviceConfig& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .Impinj.STP.Region region = 2;
  inline bool has_region() const;
  inline void clear_region();
  static const int kRegionFieldNumber = 2;
  inline const ::Impinj::STP::Region& region() const;
  inline ::Impinj::STP::Region* mutable_region();
  inline ::Impinj::STP::Region* release_region();
  inline void set_allocated_region(::Impinj::STP::Region* region);

  // required .Impinj.STP.DeviceMode device_mode = 3 [default = DEVICE_MODE_INVENTORY];
  inline bool has_device_mode() const;
  inline void clear_device_mode();
  static const int kDeviceModeFieldNumber = 3;
  inline ::Impinj::STP::DeviceMode device_mode() const;
  inline void set_device_mode(::Impinj::STP::DeviceMode value);

  // required .Impinj.STP.OperationMode operation_mode = 4 [default = OPERATION_MODE_CONTINUOUS];
  inline bool has_operation_mode() const;
  inline void clear_operation_mode();
  static const int kOperationModeFieldNumber = 4;
  inline ::Impinj::STP::OperationMode operation_mode() const;
  inline void set_operation_mode(::Impinj::STP::OperationMode value);

  // optional .Impinj.STP.OperationResponsibility operation_responsibility = 5;
  inline bool has_operation_responsibility() const;
  inline void clear_operation_responsibility();
  static const int kOperationResponsibilityFieldNumber = 5;
  inline const ::Impinj::STP::OperationResponsibility& operation_responsibility() const;
  inline ::Impinj::STP::OperationResponsibility* mutable_operation_responsibility();
  inline ::Impinj::STP::OperationResponsibility* release_operation_responsibility();
  inline void set_allocated_operation_responsibility(::Impinj::STP::OperationResponsibility* operation_responsibility);

  // optional .Impinj.STP.TriggerConfig trigger_config = 6;
  inline bool has_trigger_config() const;
  inline void clear_trigger_config();
  static const int kTriggerConfigFieldNumber = 6;
  inline const ::Impinj::STP::TriggerConfig& trigger_config() const;
  inline ::Impinj::STP::TriggerConfig* mutable_trigger_config();
  inline ::Impinj::STP::TriggerConfig* release_trigger_config();
  inline void set_allocated_trigger_config(::Impinj::STP::TriggerConfig* trigger_config);

  // optional .Impinj.STP.GPIConfig GPI_config = 7;
  inline bool has_gpi_config() const;
  inline void clear_gpi_config();
  static const int kGPIConfigFieldNumber = 7;
  inline const ::Impinj::STP::GPIConfig& gpi_config() const;
  inline ::Impinj::STP::GPIConfig* mutable_gpi_config();
  inline ::Impinj::STP::GPIConfig* release_gpi_config();
  inline void set_allocated_gpi_config(::Impinj::STP::GPIConfig* gpi_config);

  // optional .Impinj.STP.GPOConfig GPO_config = 8;
  inline bool has_gpo_config() const;
  inline void clear_gpo_config();
  static const int kGPOConfigFieldNumber = 8;
  inline const ::Impinj::STP::GPOConfig& gpo_config() const;
  inline ::Impinj::STP::GPOConfig* mutable_gpo_config();
  inline ::Impinj::STP::GPOConfig* release_gpo_config();
  inline void set_allocated_gpo_config(::Impinj::STP::GPOConfig* gpo_config);

  // optional .Impinj.STP.ReportConfig report_config = 9;
  inline bool has_report_config() const;
  inline void clear_report_config();
  static const int kReportConfigFieldNumber = 9;
  inline const ::Impinj::STP::ReportConfig& report_config() const;
  inline ::Impinj::STP::ReportConfig* mutable_report_config();
  inline ::Impinj::STP::ReportConfig* release_report_config();
  inline void set_allocated_report_config(::Impinj::STP::ReportConfig* report_config);

  // @@protoc_insertion_point(class_scope:Impinj.STP.DeviceConfig)
 private:
  inline void set_has_region();
  inline void clear_has_region();
  inline void set_has_device_mode();
  inline void clear_has_device_mode();
  inline void set_has_operation_mode();
  inline void clear_has_operation_mode();
  inline void set_has_operation_responsibility();
  inline void clear_has_operation_responsibility();
  inline void set_has_trigger_config();
  inline void clear_has_trigger_config();
  inline void set_has_gpi_config();
  inline void clear_has_gpi_config();
  inline void set_has_gpo_config();
  inline void clear_has_gpo_config();
  inline void set_has_report_config();
  inline void clear_has_report_config();

  ::Impinj::STP::Region* region_;
  int device_mode_;
  int operation_mode_;
  ::Impinj::STP::OperationResponsibility* operation_responsibility_;
  ::Impinj::STP::TriggerConfig* trigger_config_;
  ::Impinj::STP::GPIConfig* gpi_config_;
  ::Impinj::STP::GPOConfig* gpo_config_;
  ::Impinj::STP::ReportConfig* report_config_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(8 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static DeviceConfig* default_instance_;
};
// -------------------------------------------------------------------

class TriggerConfig : public ::google::protobuf::MessageLite {
 public:
  TriggerConfig();
  virtual ~TriggerConfig();

  TriggerConfig(const TriggerConfig& from);

  inline TriggerConfig& operator=(const TriggerConfig& from) {
    CopyFrom(from);
    return *this;
  }

  static const TriggerConfig& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const TriggerConfig* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(TriggerConfig* other);

  // implements Message ----------------------------------------------

  TriggerConfig* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const TriggerConfig& from);
  void MergeFrom(const TriggerConfig& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .Impinj.STP.StartTriggerConfig start_trigger_config = 1;
  inline bool has_start_trigger_config() const;
  inline void clear_start_trigger_config();
  static const int kStartTriggerConfigFieldNumber = 1;
  inline const ::Impinj::STP::StartTriggerConfig& start_trigger_config() const;
  inline ::Impinj::STP::StartTriggerConfig* mutable_start_trigger_config();
  inline ::Impinj::STP::StartTriggerConfig* release_start_trigger_config();
  inline void set_allocated_start_trigger_config(::Impinj::STP::StartTriggerConfig* start_trigger_config);

  // optional .Impinj.STP.StopTriggerConfig stop_trigger_config = 2;
  inline bool has_stop_trigger_config() const;
  inline void clear_stop_trigger_config();
  static const int kStopTriggerConfigFieldNumber = 2;
  inline const ::Impinj::STP::StopTriggerConfig& stop_trigger_config() const;
  inline ::Impinj::STP::StopTriggerConfig* mutable_stop_trigger_config();
  inline ::Impinj::STP::StopTriggerConfig* release_stop_trigger_config();
  inline void set_allocated_stop_trigger_config(::Impinj::STP::StopTriggerConfig* stop_trigger_config);

  // @@protoc_insertion_point(class_scope:Impinj.STP.TriggerConfig)
 private:
  inline void set_has_start_trigger_config();
  inline void clear_has_start_trigger_config();
  inline void set_has_stop_trigger_config();
  inline void clear_has_stop_trigger_config();

  ::Impinj::STP::StartTriggerConfig* start_trigger_config_;
  ::Impinj::STP::StopTriggerConfig* stop_trigger_config_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static TriggerConfig* default_instance_;
};
// -------------------------------------------------------------------

class StartTriggerConfig : public ::google::protobuf::MessageLite {
 public:
  StartTriggerConfig();
  virtual ~StartTriggerConfig();

  StartTriggerConfig(const StartTriggerConfig& from);

  inline StartTriggerConfig& operator=(const StartTriggerConfig& from) {
    CopyFrom(from);
    return *this;
  }

  static const StartTriggerConfig& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const StartTriggerConfig* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(StartTriggerConfig* other);

  // implements Message ----------------------------------------------

  StartTriggerConfig* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const StartTriggerConfig& from);
  void MergeFrom(const StartTriggerConfig& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional bool enable_gpi_start_trigger = 1 [default = true];
  inline bool has_enable_gpi_start_trigger() const;
  inline void clear_enable_gpi_start_trigger();
  static const int kEnableGpiStartTriggerFieldNumber = 1;
  inline bool enable_gpi_start_trigger() const;
  inline void set_enable_gpi_start_trigger(bool value);

  // @@protoc_insertion_point(class_scope:Impinj.STP.StartTriggerConfig)
 private:
  inline void set_has_enable_gpi_start_trigger();
  inline void clear_has_enable_gpi_start_trigger();

  bool enable_gpi_start_trigger_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static StartTriggerConfig* default_instance_;
};
// -------------------------------------------------------------------

class StopTriggerConfig : public ::google::protobuf::MessageLite {
 public:
  StopTriggerConfig();
  virtual ~StopTriggerConfig();

  StopTriggerConfig(const StopTriggerConfig& from);

  inline StopTriggerConfig& operator=(const StopTriggerConfig& from) {
    CopyFrom(from);
    return *this;
  }

  static const StopTriggerConfig& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const StopTriggerConfig* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(StopTriggerConfig* other);

  // implements Message ----------------------------------------------

  StopTriggerConfig* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const StopTriggerConfig& from);
  void MergeFrom(const StopTriggerConfig& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional bool enable_gpi_stop_trigger = 1 [default = true];
  inline bool has_enable_gpi_stop_trigger() const;
  inline void clear_enable_gpi_stop_trigger();
  static const int kEnableGpiStopTriggerFieldNumber = 1;
  inline bool enable_gpi_stop_trigger() const;
  inline void set_enable_gpi_stop_trigger(bool value);

  // optional uint32 timeout = 4 [default = 0];
  inline bool has_timeout() const;
  inline void clear_timeout();
  static const int kTimeoutFieldNumber = 4;
  inline ::google::protobuf::uint32 timeout() const;
  inline void set_timeout(::google::protobuf::uint32 value);

  // @@protoc_insertion_point(class_scope:Impinj.STP.StopTriggerConfig)
 private:
  inline void set_has_enable_gpi_stop_trigger();
  inline void clear_has_enable_gpi_stop_trigger();
  inline void set_has_timeout();
  inline void clear_has_timeout();

  bool enable_gpi_stop_trigger_;
  ::google::protobuf::uint32 timeout_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static StopTriggerConfig* default_instance_;
};
// -------------------------------------------------------------------

class GPIConfig : public ::google::protobuf::MessageLite {
 public:
  GPIConfig();
  virtual ~GPIConfig();

  GPIConfig(const GPIConfig& from);

  inline GPIConfig& operator=(const GPIConfig& from) {
    CopyFrom(from);
    return *this;
  }

  static const GPIConfig& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const GPIConfig* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(GPIConfig* other);

  // implements Message ----------------------------------------------

  GPIConfig* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const GPIConfig& from);
  void MergeFrom(const GPIConfig& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .Impinj.STP.GPIOSignalMode signaling_mode = 1 [default = GPIO_SIGNAL_MODE_COMBINED];
  inline bool has_signaling_mode() const;
  inline void clear_signaling_mode();
  static const int kSignalingModeFieldNumber = 1;
  inline ::Impinj::STP::GPIOSignalMode signaling_mode() const;
  inline void set_signaling_mode(::Impinj::STP::GPIOSignalMode value);

  // optional .Impinj.STP.GPIOPolarity GPI1_polarity = 2 [default = GPIO_POLARITY_ACTIVE_LOW];
  inline bool has_gpi1_polarity() const;
  inline void clear_gpi1_polarity();
  static const int kGPI1PolarityFieldNumber = 2;
  inline ::Impinj::STP::GPIOPolarity gpi1_polarity() const;
  inline void set_gpi1_polarity(::Impinj::STP::GPIOPolarity value);

  // optional .Impinj.STP.GPIOPolarity GPI2_polarity = 3 [default = GPIO_POLARITY_ACTIVE_LOW];
  inline bool has_gpi2_polarity() const;
  inline void clear_gpi2_polarity();
  static const int kGPI2PolarityFieldNumber = 3;
  inline ::Impinj::STP::GPIOPolarity gpi2_polarity() const;
  inline void set_gpi2_polarity(::Impinj::STP::GPIOPolarity value);

  // optional .Impinj.STP.GPIOPolarity GPI3_polarity = 4 [default = GPIO_POLARITY_ACTIVE_LOW];
  inline bool has_gpi3_polarity() const;
  inline void clear_gpi3_polarity();
  static const int kGPI3PolarityFieldNumber = 4;
  inline ::Impinj::STP::GPIOPolarity gpi3_polarity() const;
  inline void set_gpi3_polarity(::Impinj::STP::GPIOPolarity value);

  // @@protoc_insertion_point(class_scope:Impinj.STP.GPIConfig)
 private:
  inline void set_has_signaling_mode();
  inline void clear_has_signaling_mode();
  inline void set_has_gpi1_polarity();
  inline void clear_has_gpi1_polarity();
  inline void set_has_gpi2_polarity();
  inline void clear_has_gpi2_polarity();
  inline void set_has_gpi3_polarity();
  inline void clear_has_gpi3_polarity();

  int signaling_mode_;
  int gpi1_polarity_;
  int gpi2_polarity_;
  int gpi3_polarity_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static GPIConfig* default_instance_;
};
// -------------------------------------------------------------------

class GPOConfig : public ::google::protobuf::MessageLite {
 public:
  GPOConfig();
  virtual ~GPOConfig();

  GPOConfig(const GPOConfig& from);

  inline GPOConfig& operator=(const GPOConfig& from) {
    CopyFrom(from);
    return *this;
  }

  static const GPOConfig& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const GPOConfig* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(GPOConfig* other);

  // implements Message ----------------------------------------------

  GPOConfig* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const GPOConfig& from);
  void MergeFrom(const GPOConfig& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .Impinj.STP.GPIOSignalMode signaling_mode = 1 [default = GPIO_SIGNAL_MODE_SEPARATE];
  inline bool has_signaling_mode() const;
  inline void clear_signaling_mode();
  static const int kSignalingModeFieldNumber = 1;
  inline ::Impinj::STP::GPIOSignalMode signaling_mode() const;
  inline void set_signaling_mode(::Impinj::STP::GPIOSignalMode value);

  // optional .Impinj.STP.GPIOPolarity GPO1_polarity = 6 [default = GPIO_POLARITY_ACTIVE_LOW];
  inline bool has_gpo1_polarity() const;
  inline void clear_gpo1_polarity();
  static const int kGPO1PolarityFieldNumber = 6;
  inline ::Impinj::STP::GPIOPolarity gpo1_polarity() const;
  inline void set_gpo1_polarity(::Impinj::STP::GPIOPolarity value);

  // optional .Impinj.STP.GPIOPolarity GPO2_polarity = 2 [default = GPIO_POLARITY_ACTIVE_LOW];
  inline bool has_gpo2_polarity() const;
  inline void clear_gpo2_polarity();
  static const int kGPO2PolarityFieldNumber = 2;
  inline ::Impinj::STP::GPIOPolarity gpo2_polarity() const;
  inline void set_gpo2_polarity(::Impinj::STP::GPIOPolarity value);

  // optional .Impinj.STP.GPIOPolarity GPO3_polarity = 3 [default = GPIO_POLARITY_ACTIVE_LOW];
  inline bool has_gpo3_polarity() const;
  inline void clear_gpo3_polarity();
  static const int kGPO3PolarityFieldNumber = 3;
  inline ::Impinj::STP::GPIOPolarity gpo3_polarity() const;
  inline void set_gpo3_polarity(::Impinj::STP::GPIOPolarity value);

  // optional uint32 GPO_pulse_duration = 4 [default = 1];
  inline bool has_gpo_pulse_duration() const;
  inline void clear_gpo_pulse_duration();
  static const int kGPOPulseDurationFieldNumber = 4;
  inline ::google::protobuf::uint32 gpo_pulse_duration() const;
  inline void set_gpo_pulse_duration(::google::protobuf::uint32 value);

  // optional bool enable_operation_result_gpo = 5 [default = true];
  inline bool has_enable_operation_result_gpo() const;
  inline void clear_enable_operation_result_gpo();
  static const int kEnableOperationResultGpoFieldNumber = 5;
  inline bool enable_operation_result_gpo() const;
  inline void set_enable_operation_result_gpo(bool value);

  // @@protoc_insertion_point(class_scope:Impinj.STP.GPOConfig)
 private:
  inline void set_has_signaling_mode();
  inline void clear_has_signaling_mode();
  inline void set_has_gpo1_polarity();
  inline void clear_has_gpo1_polarity();
  inline void set_has_gpo2_polarity();
  inline void clear_has_gpo2_polarity();
  inline void set_has_gpo3_polarity();
  inline void clear_has_gpo3_polarity();
  inline void set_has_gpo_pulse_duration();
  inline void clear_has_gpo_pulse_duration();
  inline void set_has_enable_operation_result_gpo();
  inline void clear_has_enable_operation_result_gpo();

  int signaling_mode_;
  int gpo1_polarity_;
  int gpo2_polarity_;
  int gpo3_polarity_;
  ::google::protobuf::uint32 gpo_pulse_duration_;
  bool enable_operation_result_gpo_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(6 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static GPOConfig* default_instance_;
};
// -------------------------------------------------------------------

class STPDevice : public ::google::protobuf::MessageLite {
 public:
  STPDevice();
  virtual ~STPDevice();

  STPDevice(const STPDevice& from);

  inline STPDevice& operator=(const STPDevice& from) {
    CopyFrom(from);
    return *this;
  }

  static const STPDevice& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const STPDevice* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(STPDevice* other);

  // implements Message ----------------------------------------------

  STPDevice* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const STPDevice& from);
  void MergeFrom(const STPDevice& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // required string hostname = 1;
  inline bool has_hostname() const;
  inline void clear_hostname();
  static const int kHostnameFieldNumber = 1;
  inline const ::std::string& hostname() const;
  inline void set_hostname(const ::std::string& value);
  inline void set_hostname(const char* value);
  inline void set_hostname(const char* value, size_t size);
  inline ::std::string* mutable_hostname();
  inline ::std::string* release_hostname();
  inline void set_allocated_hostname(::std::string* hostname);

  // @@protoc_insertion_point(class_scope:Impinj.STP.STPDevice)
 private:
  inline void set_has_hostname();
  inline void clear_has_hostname();

  ::std::string* hostname_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static STPDevice* default_instance_;
};
// -------------------------------------------------------------------

class OperationResponsibility : public ::google::protobuf::MessageLite {
 public:
  OperationResponsibility();
  virtual ~OperationResponsibility();

  OperationResponsibility(const OperationResponsibility& from);

  inline OperationResponsibility& operator=(const OperationResponsibility& from) {
    CopyFrom(from);
    return *this;
  }

  static const OperationResponsibility& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const OperationResponsibility* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(OperationResponsibility* other);

  // implements Message ----------------------------------------------

  OperationResponsibility* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const OperationResponsibility& from);
  void MergeFrom(const OperationResponsibility& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional bytes EPC_memory_mask = 1 [default = "\377\377"];
  inline bool has_epc_memory_mask() const;
  inline void clear_epc_memory_mask();
  static const int kEPCMemoryMaskFieldNumber = 1;
  inline const ::std::string& epc_memory_mask() const;
  inline void set_epc_memory_mask(const ::std::string& value);
  inline void set_epc_memory_mask(const char* value);
  inline void set_epc_memory_mask(const void* value, size_t size);
  inline ::std::string* mutable_epc_memory_mask();
  inline ::std::string* release_epc_memory_mask();
  inline void set_allocated_epc_memory_mask(::std::string* epc_memory_mask);

  // optional bool EPC_memory_pc_word = 2 [default = true];
  inline bool has_epc_memory_pc_word() const;
  inline void clear_epc_memory_pc_word();
  static const int kEPCMemoryPcWordFieldNumber = 2;
  inline bool epc_memory_pc_word() const;
  inline void set_epc_memory_pc_word(bool value);

  // optional bool TID_config_word = 18 [default = true];
  inline bool has_tid_config_word() const;
  inline void clear_tid_config_word();
  static const int kTIDConfigWordFieldNumber = 18;
  inline bool tid_config_word() const;
  inline void set_tid_config_word(bool value);

  // optional bytes user_memory_mask = 3 [default = "\377\377\377\377\377\377\377\377"];
  inline bool has_user_memory_mask() const;
  inline void clear_user_memory_mask();
  static const int kUserMemoryMaskFieldNumber = 3;
  inline const ::std::string& user_memory_mask() const;
  inline void set_user_memory_mask(const ::std::string& value);
  inline void set_user_memory_mask(const char* value);
  inline void set_user_memory_mask(const void* value, size_t size);
  inline ::std::string* mutable_user_memory_mask();
  inline ::std::string* release_user_memory_mask();
  inline void set_allocated_user_memory_mask(::std::string* user_memory_mask);

  // optional bool secure_password = 4 [default = true];
  inline bool has_secure_password() const;
  inline void clear_secure_password();
  static const int kSecurePasswordFieldNumber = 4;
  inline bool secure_password() const;
  inline void set_secure_password(bool value);

  // optional bool access_password = 5 [default = true];
  inline bool has_access_password() const;
  inline void clear_access_password();
  static const int kAccessPasswordFieldNumber = 5;
  inline bool access_password() const;
  inline void set_access_password(bool value);

  // optional bool kill_password = 6 [default = true];
  inline bool has_kill_password() const;
  inline void clear_kill_password();
  static const int kKillPasswordFieldNumber = 6;
  inline bool kill_password() const;
  inline void set_kill_password(bool value);

  // optional bool lock_config = 7 [default = true];
  inline bool has_lock_config() const;
  inline void clear_lock_config();
  static const int kLockConfigFieldNumber = 7;
  inline bool lock_config() const;
  inline void set_lock_config(bool value);

  // optional bool blockpermalock_config = 8 [default = true];
  inline bool has_blockpermalock_config() const;
  inline void clear_blockpermalock_config();
  static const int kBlockpermalockConfigFieldNumber = 8;
  inline bool blockpermalock_config() const;
  inline void set_blockpermalock_config(bool value);

  // optional bool kill_tag = 10 [default = true];
  inline bool has_kill_tag() const;
  inline void clear_kill_tag();
  static const int kKillTagFieldNumber = 10;
  inline bool kill_tag() const;
  inline void set_kill_tag(bool value);

  // optional bool tag_specific_feature_config = 17 [default = true];
  inline bool has_tag_specific_feature_config() const;
  inline void clear_tag_specific_feature_config();
  static const int kTagSpecificFeatureConfigFieldNumber = 17;
  inline bool tag_specific_feature_config() const;
  inline void set_tag_specific_feature_config(bool value);

  // optional uint32 tags_in_view_count = 11 [default = 6];
  inline bool has_tags_in_view_count() const;
  inline void clear_tags_in_view_count();
  static const int kTagsInViewCountFieldNumber = 11;
  inline ::google::protobuf::uint32 tags_in_view_count() const;
  inline void set_tags_in_view_count(::google::protobuf::uint32 value);

  // optional uint32 tags_in_pipeline_view_count = 12 [default = 0];
  inline bool has_tags_in_pipeline_view_count() const;
  inline void clear_tags_in_pipeline_view_count();
  static const int kTagsInPipelineViewCountFieldNumber = 12;
  inline ::google::protobuf::uint32 tags_in_pipeline_view_count() const;
  inline void set_tags_in_pipeline_view_count(::google::protobuf::uint32 value);

  // repeated .Impinj.STP.STPDevice downstream_pipeline_devices = 13;
  inline int downstream_pipeline_devices_size() const;
  inline void clear_downstream_pipeline_devices();
  static const int kDownstreamPipelineDevicesFieldNumber = 13;
  inline const ::Impinj::STP::STPDevice& downstream_pipeline_devices(int index) const;
  inline ::Impinj::STP::STPDevice* mutable_downstream_pipeline_devices(int index);
  inline ::Impinj::STP::STPDevice* add_downstream_pipeline_devices();
  inline const ::google::protobuf::RepeatedPtrField< ::Impinj::STP::STPDevice >&
      downstream_pipeline_devices() const;
  inline ::google::protobuf::RepeatedPtrField< ::Impinj::STP::STPDevice >*
      mutable_downstream_pipeline_devices();

  // optional .Impinj.STP.STPDevice device_of_record = 14;
  inline bool has_device_of_record() const;
  inline void clear_device_of_record();
  static const int kDeviceOfRecordFieldNumber = 14;
  inline const ::Impinj::STP::STPDevice& device_of_record() const;
  inline ::Impinj::STP::STPDevice* mutable_device_of_record();
  inline ::Impinj::STP::STPDevice* release_device_of_record();
  inline void set_allocated_device_of_record(::Impinj::STP::STPDevice* device_of_record);

  // optional uint32 voyantic_tagsurance_test_results_cache_size = 15;
  inline bool has_voyantic_tagsurance_test_results_cache_size() const;
  inline void clear_voyantic_tagsurance_test_results_cache_size();
  static const int kVoyanticTagsuranceTestResultsCacheSizeFieldNumber = 15;
  inline ::google::protobuf::uint32 voyantic_tagsurance_test_results_cache_size() const;
  inline void set_voyantic_tagsurance_test_results_cache_size(::google::protobuf::uint32 value);

  // optional .Impinj.STP.VoidTagResponsibility void_tag_responsibility = 16;
  inline bool has_void_tag_responsibility() const;
  inline void clear_void_tag_responsibility();
  static const int kVoidTagResponsibilityFieldNumber = 16;
  inline const ::Impinj::STP::VoidTagResponsibility& void_tag_responsibility() const;
  inline ::Impinj::STP::VoidTagResponsibility* mutable_void_tag_responsibility();
  inline ::Impinj::STP::VoidTagResponsibility* release_void_tag_responsibility();
  inline void set_allocated_void_tag_responsibility(::Impinj::STP::VoidTagResponsibility* void_tag_responsibility);

  // @@protoc_insertion_point(class_scope:Impinj.STP.OperationResponsibility)
 private:
  inline void set_has_epc_memory_mask();
  inline void clear_has_epc_memory_mask();
  inline void set_has_epc_memory_pc_word();
  inline void clear_has_epc_memory_pc_word();
  inline void set_has_tid_config_word();
  inline void clear_has_tid_config_word();
  inline void set_has_user_memory_mask();
  inline void clear_has_user_memory_mask();
  inline void set_has_secure_password();
  inline void clear_has_secure_password();
  inline void set_has_access_password();
  inline void clear_has_access_password();
  inline void set_has_kill_password();
  inline void clear_has_kill_password();
  inline void set_has_lock_config();
  inline void clear_has_lock_config();
  inline void set_has_blockpermalock_config();
  inline void clear_has_blockpermalock_config();
  inline void set_has_kill_tag();
  inline void clear_has_kill_tag();
  inline void set_has_tag_specific_feature_config();
  inline void clear_has_tag_specific_feature_config();
  inline void set_has_tags_in_view_count();
  inline void clear_has_tags_in_view_count();
  inline void set_has_tags_in_pipeline_view_count();
  inline void clear_has_tags_in_pipeline_view_count();
  inline void set_has_device_of_record();
  inline void clear_has_device_of_record();
  inline void set_has_voyantic_tagsurance_test_results_cache_size();
  inline void clear_has_voyantic_tagsurance_test_results_cache_size();
  inline void set_has_void_tag_responsibility();
  inline void clear_has_void_tag_responsibility();

  ::std::string* epc_memory_mask_;
  static ::std::string* _default_epc_memory_mask_;
  ::std::string* user_memory_mask_;
  static ::std::string* _default_user_memory_mask_;
  bool epc_memory_pc_word_;
  bool tid_config_word_;
  bool secure_password_;
  bool access_password_;
  bool kill_password_;
  bool lock_config_;
  bool blockpermalock_config_;
  bool kill_tag_;
  bool tag_specific_feature_config_;
  ::google::protobuf::uint32 tags_in_view_count_;
  ::google::protobuf::RepeatedPtrField< ::Impinj::STP::STPDevice > downstream_pipeline_devices_;
  ::google::protobuf::uint32 tags_in_pipeline_view_count_;
  ::google::protobuf::uint32 voyantic_tagsurance_test_results_cache_size_;
  ::Impinj::STP::STPDevice* device_of_record_;
  ::Impinj::STP::VoidTagResponsibility* void_tag_responsibility_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(17 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static OperationResponsibility* default_instance_;
};
// -------------------------------------------------------------------

class VoidTagResponsibility : public ::google::protobuf::MessageLite {
 public:
  VoidTagResponsibility();
  virtual ~VoidTagResponsibility();

  VoidTagResponsibility(const VoidTagResponsibility& from);

  inline VoidTagResponsibility& operator=(const VoidTagResponsibility& from) {
    CopyFrom(from);
    return *this;
  }

  static const VoidTagResponsibility& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const VoidTagResponsibility* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(VoidTagResponsibility* other);

  // implements Message ----------------------------------------------

  VoidTagResponsibility* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const VoidTagResponsibility& from);
  void MergeFrom(const VoidTagResponsibility& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional bool pc_word_to_zero = 1 [default = true];
  inline bool has_pc_word_to_zero() const;
  inline void clear_pc_word_to_zero();
  static const int kPcWordToZeroFieldNumber = 1;
  inline bool pc_word_to_zero() const;
  inline void set_pc_word_to_zero(bool value);

  // optional bool first_epc_words = 2 [default = true];
  inline bool has_first_epc_words() const;
  inline void clear_first_epc_words();
  static const int kFirstEpcWordsFieldNumber = 2;
  inline bool first_epc_words() const;
  inline void set_first_epc_words(bool value);

  // optional bool permalock = 3 [default = true];
  inline bool has_permalock() const;
  inline void clear_permalock();
  static const int kPermalockFieldNumber = 3;
  inline bool permalock() const;
  inline void set_permalock(bool value);

  // optional bool kill = 4 [default = true];
  inline bool has_kill() const;
  inline void clear_kill();
  static const int kKillFieldNumber = 4;
  inline bool kill() const;
  inline void set_kill(bool value);

  // @@protoc_insertion_point(class_scope:Impinj.STP.VoidTagResponsibility)
 private:
  inline void set_has_pc_word_to_zero();
  inline void clear_has_pc_word_to_zero();
  inline void set_has_first_epc_words();
  inline void clear_has_first_epc_words();
  inline void set_has_permalock();
  inline void clear_has_permalock();
  inline void set_has_kill();
  inline void clear_has_kill();

  bool pc_word_to_zero_;
  bool first_epc_words_;
  bool permalock_;
  bool kill_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static VoidTagResponsibility* default_instance_;
};
// -------------------------------------------------------------------

class OperationSummaryReportConfig : public ::google::protobuf::MessageLite {
 public:
  OperationSummaryReportConfig();
  virtual ~OperationSummaryReportConfig();

  OperationSummaryReportConfig(const OperationSummaryReportConfig& from);

  inline OperationSummaryReportConfig& operator=(const OperationSummaryReportConfig& from) {
    CopyFrom(from);
    return *this;
  }

  static const OperationSummaryReportConfig& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const OperationSummaryReportConfig* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(OperationSummaryReportConfig* other);

  // implements Message ----------------------------------------------

  OperationSummaryReportConfig* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const OperationSummaryReportConfig& from);
  void MergeFrom(const OperationSummaryReportConfig& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // required bool enable_operation_summary_reports = 1 [default = true];
  inline bool has_enable_operation_summary_reports() const;
  inline void clear_enable_operation_summary_reports();
  static const int kEnableOperationSummaryReportsFieldNumber = 1;
  inline bool enable_operation_summary_reports() const;
  inline void set_enable_operation_summary_reports(bool value);

  // @@protoc_insertion_point(class_scope:Impinj.STP.OperationSummaryReportConfig)
 private:
  inline void set_has_enable_operation_summary_reports();
  inline void clear_has_enable_operation_summary_reports();

  bool enable_operation_summary_reports_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static OperationSummaryReportConfig* default_instance_;
};
// -------------------------------------------------------------------

class TagOperationReportConfig : public ::google::protobuf::MessageLite {
 public:
  TagOperationReportConfig();
  virtual ~TagOperationReportConfig();

  TagOperationReportConfig(const TagOperationReportConfig& from);

  inline TagOperationReportConfig& operator=(const TagOperationReportConfig& from) {
    CopyFrom(from);
    return *this;
  }

  static const TagOperationReportConfig& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const TagOperationReportConfig* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(TagOperationReportConfig* other);

  // implements Message ----------------------------------------------

  TagOperationReportConfig* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const TagOperationReportConfig& from);
  void MergeFrom(const TagOperationReportConfig& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // required bool enable_tag_operation_reports = 1 [default = true];
  inline bool has_enable_tag_operation_reports() const;
  inline void clear_enable_tag_operation_reports();
  static const int kEnableTagOperationReportsFieldNumber = 1;
  inline bool enable_tag_operation_reports() const;
  inline void set_enable_tag_operation_reports(bool value);

  // optional bool enable_tag_operation_retry_reports = 2 [default = false];
  inline bool has_enable_tag_operation_retry_reports() const;
  inline void clear_enable_tag_operation_retry_reports();
  static const int kEnableTagOperationRetryReportsFieldNumber = 2;
  inline bool enable_tag_operation_retry_reports() const;
  inline void set_enable_tag_operation_retry_reports(bool value);

  // optional .Impinj.STP.TagOperationReportTrigger tag_operation_report_trigger = 3 [default = TAG_OPERATION_REPORT_TRIGGER_IMMEDIATE];
  inline bool has_tag_operation_report_trigger() const;
  inline void clear_tag_operation_report_trigger();
  static const int kTagOperationReportTriggerFieldNumber = 3;
  inline ::Impinj::STP::TagOperationReportTrigger tag_operation_report_trigger() const;
  inline void set_tag_operation_report_trigger(::Impinj::STP::TagOperationReportTrigger value);

  // optional bool enable_reporting_over_serial_port = 4 [default = false];
  inline bool has_enable_reporting_over_serial_port() const;
  inline void clear_enable_reporting_over_serial_port();
  static const int kEnableReportingOverSerialPortFieldNumber = 4;
  inline bool enable_reporting_over_serial_port() const;
  inline void set_enable_reporting_over_serial_port(bool value);

  // optional bool send_serial_report_after_GPO_deassert = 5 [default = false];
  inline bool has_send_serial_report_after_gpo_deassert() const;
  inline void clear_send_serial_report_after_gpo_deassert();
  static const int kSendSerialReportAfterGPODeassertFieldNumber = 5;
  inline bool send_serial_report_after_gpo_deassert() const;
  inline void set_send_serial_report_after_gpo_deassert(bool value);

  // optional bool enable_epc_in_serial_report = 6 [default = false];
  inline bool has_enable_epc_in_serial_report() const;
  inline void clear_enable_epc_in_serial_report();
  static const int kEnableEpcInSerialReportFieldNumber = 6;
  inline bool enable_epc_in_serial_report() const;
  inline void set_enable_epc_in_serial_report(bool value);

  // optional bool enable_tag_operation_pass_already_done_reports = 7 [default = false];
  inline bool has_enable_tag_operation_pass_already_done_reports() const;
  inline void clear_enable_tag_operation_pass_already_done_reports();
  static const int kEnableTagOperationPassAlreadyDoneReportsFieldNumber = 7;
  inline bool enable_tag_operation_pass_already_done_reports() const;
  inline void set_enable_tag_operation_pass_already_done_reports(bool value);

  // @@protoc_insertion_point(class_scope:Impinj.STP.TagOperationReportConfig)
 private:
  inline void set_has_enable_tag_operation_reports();
  inline void clear_has_enable_tag_operation_reports();
  inline void set_has_enable_tag_operation_retry_reports();
  inline void clear_has_enable_tag_operation_retry_reports();
  inline void set_has_tag_operation_report_trigger();
  inline void clear_has_tag_operation_report_trigger();
  inline void set_has_enable_reporting_over_serial_port();
  inline void clear_has_enable_reporting_over_serial_port();
  inline void set_has_send_serial_report_after_gpo_deassert();
  inline void clear_has_send_serial_report_after_gpo_deassert();
  inline void set_has_enable_epc_in_serial_report();
  inline void clear_has_enable_epc_in_serial_report();
  inline void set_has_enable_tag_operation_pass_already_done_reports();
  inline void clear_has_enable_tag_operation_pass_already_done_reports();

  int tag_operation_report_trigger_;
  bool enable_tag_operation_reports_;
  bool enable_tag_operation_retry_reports_;
  bool enable_reporting_over_serial_port_;
  bool send_serial_report_after_gpo_deassert_;
  bool enable_epc_in_serial_report_;
  bool enable_tag_operation_pass_already_done_reports_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(7 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static TagOperationReportConfig* default_instance_;
};
// -------------------------------------------------------------------

class ReportConfig : public ::google::protobuf::MessageLite {
 public:
  ReportConfig();
  virtual ~ReportConfig();

  ReportConfig(const ReportConfig& from);

  inline ReportConfig& operator=(const ReportConfig& from) {
    CopyFrom(from);
    return *this;
  }

  static const ReportConfig& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const ReportConfig* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(ReportConfig* other);

  // implements Message ----------------------------------------------

  ReportConfig* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const ReportConfig& from);
  void MergeFrom(const ReportConfig& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .Impinj.STP.DeviceEventConfig device_event_config = 1;
  inline bool has_device_event_config() const;
  inline void clear_device_event_config();
  static const int kDeviceEventConfigFieldNumber = 1;
  inline const ::Impinj::STP::DeviceEventConfig& device_event_config() const;
  inline ::Impinj::STP::DeviceEventConfig* mutable_device_event_config();
  inline ::Impinj::STP::DeviceEventConfig* release_device_event_config();
  inline void set_allocated_device_event_config(::Impinj::STP::DeviceEventConfig* device_event_config);

  // optional .Impinj.STP.OperationSummaryReportConfig operation_summary_report_config = 2;
  inline bool has_operation_summary_report_config() const;
  inline void clear_operation_summary_report_config();
  static const int kOperationSummaryReportConfigFieldNumber = 2;
  inline const ::Impinj::STP::OperationSummaryReportConfig& operation_summary_report_config() const;
  inline ::Impinj::STP::OperationSummaryReportConfig* mutable_operation_summary_report_config();
  inline ::Impinj::STP::OperationSummaryReportConfig* release_operation_summary_report_config();
  inline void set_allocated_operation_summary_report_config(::Impinj::STP::OperationSummaryReportConfig* operation_summary_report_config);

  // optional .Impinj.STP.TagOperationReportConfig tag_operation_report_config = 3;
  inline bool has_tag_operation_report_config() const;
  inline void clear_tag_operation_report_config();
  static const int kTagOperationReportConfigFieldNumber = 3;
  inline const ::Impinj::STP::TagOperationReportConfig& tag_operation_report_config() const;
  inline ::Impinj::STP::TagOperationReportConfig* mutable_tag_operation_report_config();
  inline ::Impinj::STP::TagOperationReportConfig* release_tag_operation_report_config();
  inline void set_allocated_tag_operation_report_config(::Impinj::STP::TagOperationReportConfig* tag_operation_report_config);

  // @@protoc_insertion_point(class_scope:Impinj.STP.ReportConfig)
 private:
  inline void set_has_device_event_config();
  inline void clear_has_device_event_config();
  inline void set_has_operation_summary_report_config();
  inline void clear_has_operation_summary_report_config();
  inline void set_has_tag_operation_report_config();
  inline void clear_has_tag_operation_report_config();

  ::Impinj::STP::DeviceEventConfig* device_event_config_;
  ::Impinj::STP::OperationSummaryReportConfig* operation_summary_report_config_;
  ::Impinj::STP::TagOperationReportConfig* tag_operation_report_config_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static ReportConfig* default_instance_;
};
// -------------------------------------------------------------------

class AntennaConfig : public ::google::protobuf::MessageLite {
 public:
  AntennaConfig();
  virtual ~AntennaConfig();

  AntennaConfig(const AntennaConfig& from);

  inline AntennaConfig& operator=(const AntennaConfig& from) {
    CopyFrom(from);
    return *this;
  }

  static const AntennaConfig& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const AntennaConfig* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(AntennaConfig* other);

  // implements Message ----------------------------------------------

  AntennaConfig* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const AntennaConfig& from);
  void MergeFrom(const AntennaConfig& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // required uint32 antenna_ID = 1;
  inline bool has_antenna_id() const;
  inline void clear_antenna_id();
  static const int kAntennaIDFieldNumber = 1;
  inline ::google::protobuf::uint32 antenna_id() const;
  inline void set_antenna_id(::google::protobuf::uint32 value);

  // optional .Impinj.STP.Gen2Mode gen2_mode = 4 [default = GEN2_MODE_MAX_THROUGHPUT];
  inline bool has_gen2_mode() const;
  inline void clear_gen2_mode();
  static const int kGen2ModeFieldNumber = 4;
  inline ::Impinj::STP::Gen2Mode gen2_mode() const;
  inline void set_gen2_mode(::Impinj::STP::Gen2Mode value);

  // optional .Impinj.STP.InventorySearchMode inventory_search_mode = 5 [default = INVENTORY_SEARCH_MODE_SINGLE_TARGET_A_TO_B_MONZA_TAGFOCUS];
  inline bool has_inventory_search_mode() const;
  inline void clear_inventory_search_mode();
  static const int kInventorySearchModeFieldNumber = 5;
  inline ::Impinj::STP::InventorySearchMode inventory_search_mode() const;
  inline void set_inventory_search_mode(::Impinj::STP::InventorySearchMode value);

  // optional .Impinj.STP.Gen2Session gen2_session = 6 [default = GEN2_SESSION_1];
  inline bool has_gen2_session() const;
  inline void clear_gen2_session();
  static const int kGen2SessionFieldNumber = 6;
  inline ::Impinj::STP::Gen2Session gen2_session() const;
  inline void set_gen2_session(::Impinj::STP::Gen2Session value);

  // optional sint32 transmit_power = 7 [default = 3000];
  inline bool has_transmit_power() const;
  inline void clear_transmit_power();
  static const int kTransmitPowerFieldNumber = 7;
  inline ::google::protobuf::int32 transmit_power() const;
  inline void set_transmit_power(::google::protobuf::int32 value);

  // optional sint32 receive_sensitivity = 8;
  inline bool has_receive_sensitivity() const;
  inline void clear_receive_sensitivity();
  static const int kReceiveSensitivityFieldNumber = 8;
  inline ::google::protobuf::int32 receive_sensitivity() const;
  inline void set_receive_sensitivity(::google::protobuf::int32 value);

  // optional uint32 tag_population_estimate = 10 [default = 32];
  inline bool has_tag_population_estimate() const;
  inline void clear_tag_population_estimate();
  static const int kTagPopulationEstimateFieldNumber = 10;
  inline ::google::protobuf::uint32 tag_population_estimate() const;
  inline void set_tag_population_estimate(::google::protobuf::uint32 value);

  // optional uint32 minimum_dwell_time = 11 [default = 0];
  inline bool has_minimum_dwell_time() const;
  inline void clear_minimum_dwell_time();
  static const int kMinimumDwellTimeFieldNumber = 11;
  inline ::google::protobuf::uint32 minimum_dwell_time() const;
  inline void set_minimum_dwell_time(::google::protobuf::uint32 value);

  // optional uint32 maximum_dwell_time = 12 [default = 0];
  inline bool has_maximum_dwell_time() const;
  inline void clear_maximum_dwell_time();
  static const int kMaximumDwellTimeFieldNumber = 12;
  inline ::google::protobuf::uint32 maximum_dwell_time() const;
  inline void set_maximum_dwell_time(::google::protobuf::uint32 value);

  // optional bool enable_query_for_q_increase = 13 [default = false];
  inline bool has_enable_query_for_q_increase() const;
  inline void clear_enable_query_for_q_increase();
  static const int kEnableQueryForQIncreaseFieldNumber = 13;
  inline bool enable_query_for_q_increase() const;
  inline void set_enable_query_for_q_increase(bool value);

  // optional bool enable_query_for_q_decrease = 14 [default = false];
  inline bool has_enable_query_for_q_decrease() const;
  inline void clear_enable_query_for_q_decrease();
  static const int kEnableQueryForQDecreaseFieldNumber = 14;
  inline bool enable_query_for_q_decrease() const;
  inline void set_enable_query_for_q_decrease(bool value);

  // optional bool enable_query_at_u_cycle_end = 15 [default = false];
  inline bool has_enable_query_at_u_cycle_end() const;
  inline void clear_enable_query_at_u_cycle_end();
  static const int kEnableQueryAtUCycleEndFieldNumber = 15;
  inline bool enable_query_at_u_cycle_end() const;
  inline void set_enable_query_at_u_cycle_end(bool value);

  // optional bool enable_adaptive_tag_population_estimate = 16 [default = false];
  inline bool has_enable_adaptive_tag_population_estimate() const;
  inline void clear_enable_adaptive_tag_population_estimate();
  static const int kEnableAdaptiveTagPopulationEstimateFieldNumber = 16;
  inline bool enable_adaptive_tag_population_estimate() const;
  inline void set_enable_adaptive_tag_population_estimate(bool value);

  // @@protoc_insertion_point(class_scope:Impinj.STP.AntennaConfig)
 private:
  inline void set_has_antenna_id();
  inline void clear_has_antenna_id();
  inline void set_has_gen2_mode();
  inline void clear_has_gen2_mode();
  inline void set_has_inventory_search_mode();
  inline void clear_has_inventory_search_mode();
  inline void set_has_gen2_session();
  inline void clear_has_gen2_session();
  inline void set_has_transmit_power();
  inline void clear_has_transmit_power();
  inline void set_has_receive_sensitivity();
  inline void clear_has_receive_sensitivity();
  inline void set_has_tag_population_estimate();
  inline void clear_has_tag_population_estimate();
  inline void set_has_minimum_dwell_time();
  inline void clear_has_minimum_dwell_time();
  inline void set_has_maximum_dwell_time();
  inline void clear_has_maximum_dwell_time();
  inline void set_has_enable_query_for_q_increase();
  inline void clear_has_enable_query_for_q_increase();
  inline void set_has_enable_query_for_q_decrease();
  inline void clear_has_enable_query_for_q_decrease();
  inline void set_has_enable_query_at_u_cycle_end();
  inline void clear_has_enable_query_at_u_cycle_end();
  inline void set_has_enable_adaptive_tag_population_estimate();
  inline void clear_has_enable_adaptive_tag_population_estimate();

  ::google::protobuf::uint32 antenna_id_;
  int gen2_mode_;
  int inventory_search_mode_;
  int gen2_session_;
  ::google::protobuf::int32 transmit_power_;
  ::google::protobuf::int32 receive_sensitivity_;
  ::google::protobuf::uint32 tag_population_estimate_;
  ::google::protobuf::uint32 minimum_dwell_time_;
  ::google::protobuf::uint32 maximum_dwell_time_;
  bool enable_query_for_q_increase_;
  bool enable_query_for_q_decrease_;
  bool enable_query_at_u_cycle_end_;
  bool enable_adaptive_tag_population_estimate_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(13 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static AntennaConfig* default_instance_;
};
// -------------------------------------------------------------------

class AntennasConfig : public ::google::protobuf::MessageLite {
 public:
  AntennasConfig();
  virtual ~AntennasConfig();

  AntennasConfig(const AntennasConfig& from);

  inline AntennasConfig& operator=(const AntennasConfig& from) {
    CopyFrom(from);
    return *this;
  }

  static const AntennasConfig& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const AntennasConfig* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(AntennasConfig* other);

  // implements Message ----------------------------------------------

  AntennasConfig* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const AntennasConfig& from);
  void MergeFrom(const AntennasConfig& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated .Impinj.STP.AntennaConfig antenna_config = 1;
  inline int antenna_config_size() const;
  inline void clear_antenna_config();
  static const int kAntennaConfigFieldNumber = 1;
  inline const ::Impinj::STP::AntennaConfig& antenna_config(int index) const;
  inline ::Impinj::STP::AntennaConfig* mutable_antenna_config(int index);
  inline ::Impinj::STP::AntennaConfig* add_antenna_config();
  inline const ::google::protobuf::RepeatedPtrField< ::Impinj::STP::AntennaConfig >&
      antenna_config() const;
  inline ::google::protobuf::RepeatedPtrField< ::Impinj::STP::AntennaConfig >*
      mutable_antenna_config();

  // @@protoc_insertion_point(class_scope:Impinj.STP.AntennasConfig)
 private:

  ::google::protobuf::RepeatedPtrField< ::Impinj::STP::AntennaConfig > antenna_config_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static AntennasConfig* default_instance_;
};
// -------------------------------------------------------------------

class InventoryJob : public ::google::protobuf::MessageLite {
 public:
  InventoryJob();
  virtual ~InventoryJob();

  InventoryJob(const InventoryJob& from);

  inline InventoryJob& operator=(const InventoryJob& from) {
    CopyFrom(from);
    return *this;
  }

  static const InventoryJob& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const InventoryJob* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(InventoryJob* other);

  // implements Message ----------------------------------------------

  InventoryJob* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const InventoryJob& from);
  void MergeFrom(const InventoryJob& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional uint32 job_id = 1 [default = 1];
  inline bool has_job_id() const;
  inline void clear_job_id();
  static const int kJobIdFieldNumber = 1;
  inline ::google::protobuf::uint32 job_id() const;
  inline void set_job_id(::google::protobuf::uint32 value);

  // optional .Impinj.STP.UserMemory user_memory = 2;
  inline bool has_user_memory() const;
  inline void clear_user_memory();
  static const int kUserMemoryFieldNumber = 2;
  inline const ::Impinj::STP::UserMemory& user_memory() const;
  inline ::Impinj::STP::UserMemory* mutable_user_memory();
  inline ::Impinj::STP::UserMemory* release_user_memory();
  inline void set_allocated_user_memory(::Impinj::STP::UserMemory* user_memory);

  // @@protoc_insertion_point(class_scope:Impinj.STP.InventoryJob)
 private:
  inline void set_has_job_id();
  inline void clear_has_job_id();
  inline void set_has_user_memory();
  inline void clear_has_user_memory();

  ::Impinj::STP::UserMemory* user_memory_;
  ::google::protobuf::uint32 job_id_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static InventoryJob* default_instance_;
};
// -------------------------------------------------------------------

class CartonContentsJob : public ::google::protobuf::MessageLite {
 public:
  CartonContentsJob();
  virtual ~CartonContentsJob();

  CartonContentsJob(const CartonContentsJob& from);

  inline CartonContentsJob& operator=(const CartonContentsJob& from) {
    CopyFrom(from);
    return *this;
  }

  static const CartonContentsJob& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const CartonContentsJob* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(CartonContentsJob* other);

  // implements Message ----------------------------------------------

  CartonContentsJob* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const CartonContentsJob& from);
  void MergeFrom(const CartonContentsJob& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional uint32 job_id = 1 [default = 1];
  inline bool has_job_id() const;
  inline void clear_job_id();
  static const int kJobIdFieldNumber = 1;
  inline ::google::protobuf::uint32 job_id() const;
  inline void set_job_id(::google::protobuf::uint32 value);

  // optional uint32 enter_trigger_offset = 6;
  inline bool has_enter_trigger_offset() const;
  inline void clear_enter_trigger_offset();
  static const int kEnterTriggerOffsetFieldNumber = 6;
  inline ::google::protobuf::uint32 enter_trigger_offset() const;
  inline void set_enter_trigger_offset(::google::protobuf::uint32 value);

  // optional uint32 exit_trigger_offset = 7;
  inline bool has_exit_trigger_offset() const;
  inline void clear_exit_trigger_offset();
  static const int kExitTriggerOffsetFieldNumber = 7;
  inline ::google::protobuf::uint32 exit_trigger_offset() const;
  inline void set_exit_trigger_offset(::google::protobuf::uint32 value);

  // optional uint32 carton_velocity = 4;
  inline bool has_carton_velocity() const;
  inline void clear_carton_velocity();
  static const int kCartonVelocityFieldNumber = 4;
  inline ::google::protobuf::uint32 carton_velocity() const;
  inline void set_carton_velocity(::google::protobuf::uint32 value);

  // optional bool read_tid = 8 [default = true];
  inline bool has_read_tid() const;
  inline void clear_read_tid();
  static const int kReadTidFieldNumber = 8;
  inline bool read_tid() const;
  inline void set_read_tid(bool value);

  // optional uint32 carton_spacing = 5;
  inline bool has_carton_spacing() const;
  inline void clear_carton_spacing();
  static const int kCartonSpacingFieldNumber = 5;
  inline ::google::protobuf::uint32 carton_spacing() const;
  inline void set_carton_spacing(::google::protobuf::uint32 value);

  // optional uint32 start_trigger_offset = 2;
  inline bool has_start_trigger_offset() const;
  inline void clear_start_trigger_offset();
  static const int kStartTriggerOffsetFieldNumber = 2;
  inline ::google::protobuf::uint32 start_trigger_offset() const;
  inline void set_start_trigger_offset(::google::protobuf::uint32 value);

  // optional uint32 stop_trigger_offset = 3;
  inline bool has_stop_trigger_offset() const;
  inline void clear_stop_trigger_offset();
  static const int kStopTriggerOffsetFieldNumber = 3;
  inline ::google::protobuf::uint32 stop_trigger_offset() const;
  inline void set_stop_trigger_offset(::google::protobuf::uint32 value);

  // @@protoc_insertion_point(class_scope:Impinj.STP.CartonContentsJob)
 private:
  inline void set_has_job_id();
  inline void clear_has_job_id();
  inline void set_has_enter_trigger_offset();
  inline void clear_has_enter_trigger_offset();
  inline void set_has_exit_trigger_offset();
  inline void clear_has_exit_trigger_offset();
  inline void set_has_carton_velocity();
  inline void clear_has_carton_velocity();
  inline void set_has_read_tid();
  inline void clear_has_read_tid();
  inline void set_has_carton_spacing();
  inline void clear_has_carton_spacing();
  inline void set_has_start_trigger_offset();
  inline void clear_has_start_trigger_offset();
  inline void set_has_stop_trigger_offset();
  inline void clear_has_stop_trigger_offset();

  ::google::protobuf::uint32 job_id_;
  ::google::protobuf::uint32 enter_trigger_offset_;
  ::google::protobuf::uint32 exit_trigger_offset_;
  ::google::protobuf::uint32 carton_velocity_;
  bool read_tid_;
  ::google::protobuf::uint32 carton_spacing_;
  ::google::protobuf::uint32 start_trigger_offset_;
  ::google::protobuf::uint32 stop_trigger_offset_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(8 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static CartonContentsJob* default_instance_;
};
// -------------------------------------------------------------------

class VoidTagConfig : public ::google::protobuf::MessageLite {
 public:
  VoidTagConfig();
  virtual ~VoidTagConfig();

  VoidTagConfig(const VoidTagConfig& from);

  inline VoidTagConfig& operator=(const VoidTagConfig& from) {
    CopyFrom(from);
    return *this;
  }

  static const VoidTagConfig& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const VoidTagConfig* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(VoidTagConfig* other);

  // implements Message ----------------------------------------------

  VoidTagConfig* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const VoidTagConfig& from);
  void MergeFrom(const VoidTagConfig& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional bool kill_tag = 1;
  inline bool has_kill_tag() const;
  inline void clear_kill_tag();
  static const int kKillTagFieldNumber = 1;
  inline bool kill_tag() const;
  inline void set_kill_tag(bool value);

  // optional bool permalock_all_banks = 2;
  inline bool has_permalock_all_banks() const;
  inline void clear_permalock_all_banks();
  static const int kPermalockAllBanksFieldNumber = 2;
  inline bool permalock_all_banks() const;
  inline void set_permalock_all_banks(bool value);

  // @@protoc_insertion_point(class_scope:Impinj.STP.VoidTagConfig)
 private:
  inline void set_has_kill_tag();
  inline void clear_has_kill_tag();
  inline void set_has_permalock_all_banks();
  inline void clear_has_permalock_all_banks();

  bool kill_tag_;
  bool permalock_all_banks_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static VoidTagConfig* default_instance_;
};
// -------------------------------------------------------------------

class Filter : public ::google::protobuf::MessageLite {
 public:
  Filter();
  virtual ~Filter();

  Filter(const Filter& from);

  inline Filter& operator=(const Filter& from) {
    CopyFrom(from);
    return *this;
  }

  static const Filter& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const Filter* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(Filter* other);

  // implements Message ----------------------------------------------

  Filter* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const Filter& from);
  void MergeFrom(const Filter& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional bytes data = 1;
  inline bool has_data() const;
  inline void clear_data();
  static const int kDataFieldNumber = 1;
  inline const ::std::string& data() const;
  inline void set_data(const ::std::string& value);
  inline void set_data(const char* value);
  inline void set_data(const void* value, size_t size);
  inline ::std::string* mutable_data();
  inline ::std::string* release_data();
  inline void set_allocated_data(::std::string* data);

  // optional bytes mask = 2;
  inline bool has_mask() const;
  inline void clear_mask();
  static const int kMaskFieldNumber = 2;
  inline const ::std::string& mask() const;
  inline void set_mask(const ::std::string& value);
  inline void set_mask(const char* value);
  inline void set_mask(const void* value, size_t size);
  inline ::std::string* mutable_mask();
  inline ::std::string* release_mask();
  inline void set_allocated_mask(::std::string* mask);

  // optional uint32 word_offset = 3 [default = 0];
  inline bool has_word_offset() const;
  inline void clear_word_offset();
  static const int kWordOffsetFieldNumber = 3;
  inline ::google::protobuf::uint32 word_offset() const;
  inline void set_word_offset(::google::protobuf::uint32 value);

  // @@protoc_insertion_point(class_scope:Impinj.STP.Filter)
 private:
  inline void set_has_data();
  inline void clear_has_data();
  inline void set_has_mask();
  inline void clear_has_mask();
  inline void set_has_word_offset();
  inline void clear_has_word_offset();

  ::std::string* data_;
  ::std::string* mask_;
  ::google::protobuf::uint32 word_offset_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static Filter* default_instance_;
};
// -------------------------------------------------------------------

class SerializationJobFilters : public ::google::protobuf::MessageLite {
 public:
  SerializationJobFilters();
  virtual ~SerializationJobFilters();

  SerializationJobFilters(const SerializationJobFilters& from);

  inline SerializationJobFilters& operator=(const SerializationJobFilters& from) {
    CopyFrom(from);
    return *this;
  }

  static const SerializationJobFilters& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const SerializationJobFilters* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(SerializationJobFilters* other);

  // implements Message ----------------------------------------------

  SerializationJobFilters* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const SerializationJobFilters& from);
  void MergeFrom(const SerializationJobFilters& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated .Impinj.STP.Filter tid_filters = 1;
  inline int tid_filters_size() const;
  inline void clear_tid_filters();
  static const int kTidFiltersFieldNumber = 1;
  inline const ::Impinj::STP::Filter& tid_filters(int index) const;
  inline ::Impinj::STP::Filter* mutable_tid_filters(int index);
  inline ::Impinj::STP::Filter* add_tid_filters();
  inline const ::google::protobuf::RepeatedPtrField< ::Impinj::STP::Filter >&
      tid_filters() const;
  inline ::google::protobuf::RepeatedPtrField< ::Impinj::STP::Filter >*
      mutable_tid_filters();

  // repeated .Impinj.STP.Filter epc_filters = 2;
  inline int epc_filters_size() const;
  inline void clear_epc_filters();
  static const int kEpcFiltersFieldNumber = 2;
  inline const ::Impinj::STP::Filter& epc_filters(int index) const;
  inline ::Impinj::STP::Filter* mutable_epc_filters(int index);
  inline ::Impinj::STP::Filter* add_epc_filters();
  inline const ::google::protobuf::RepeatedPtrField< ::Impinj::STP::Filter >&
      epc_filters() const;
  inline ::google::protobuf::RepeatedPtrField< ::Impinj::STP::Filter >*
      mutable_epc_filters();

  // @@protoc_insertion_point(class_scope:Impinj.STP.SerializationJobFilters)
 private:

  ::google::protobuf::RepeatedPtrField< ::Impinj::STP::Filter > tid_filters_;
  ::google::protobuf::RepeatedPtrField< ::Impinj::STP::Filter > epc_filters_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static SerializationJobFilters* default_instance_;
};
// -------------------------------------------------------------------

class SerializationJob : public ::google::protobuf::MessageLite {
 public:
  SerializationJob();
  virtual ~SerializationJob();

  SerializationJob(const SerializationJob& from);

  inline SerializationJob& operator=(const SerializationJob& from) {
    CopyFrom(from);
    return *this;
  }

  static const SerializationJob& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const SerializationJob* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(SerializationJob* other);

  // implements Message ----------------------------------------------

  SerializationJob* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const SerializationJob& from);
  void MergeFrom(const SerializationJob& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // required uint32 job_id = 1;
  inline bool has_job_id() const;
  inline void clear_job_id();
  static const int kJobIdFieldNumber = 1;
  inline ::google::protobuf::uint32 job_id() const;
  inline void set_job_id(::google::protobuf::uint32 value);

  // required .Impinj.STP.SerializationJobType job_type = 2;
  inline bool has_job_type() const;
  inline void clear_job_type();
  static const int kJobTypeFieldNumber = 2;
  inline ::Impinj::STP::SerializationJobType job_type() const;
  inline void set_job_type(::Impinj::STP::SerializationJobType value);

  // optional .Impinj.STP.SerializationJobCompletionCriteria job_completion_criteria = 3 [default = SERIALIZATION_JOB_COMPLETION_CRITERIA_NONE];
  inline bool has_job_completion_criteria() const;
  inline void clear_job_completion_criteria();
  static const int kJobCompletionCriteriaFieldNumber = 3;
  inline ::Impinj::STP::SerializationJobCompletionCriteria job_completion_criteria() const;
  inline void set_job_completion_criteria(::Impinj::STP::SerializationJobCompletionCriteria value);

  // optional uint32 operation_quantity = 4;
  inline bool has_operation_quantity() const;
  inline void clear_operation_quantity();
  static const int kOperationQuantityFieldNumber = 4;
  inline ::google::protobuf::uint32 operation_quantity() const;
  inline void set_operation_quantity(::google::protobuf::uint32 value);

  // optional .Impinj.STP.EPCMemory EPC_memory = 5;
  inline bool has_epc_memory() const;
  inline void clear_epc_memory();
  static const int kEPCMemoryFieldNumber = 5;
  inline const ::Impinj::STP::EPCMemory& epc_memory() const;
  inline ::Impinj::STP::EPCMemory* mutable_epc_memory();
  inline ::Impinj::STP::EPCMemory* release_epc_memory();
  inline void set_allocated_epc_memory(::Impinj::STP::EPCMemory* epc_memory);

  // optional .Impinj.STP.TIDMemory TID_memory = 6;
  inline bool has_tid_memory() const;
  inline void clear_tid_memory();
  static const int kTIDMemoryFieldNumber = 6;
  inline const ::Impinj::STP::TIDMemory& tid_memory() const;
  inline ::Impinj::STP::TIDMemory* mutable_tid_memory();
  inline ::Impinj::STP::TIDMemory* release_tid_memory();
  inline void set_allocated_tid_memory(::Impinj::STP::TIDMemory* tid_memory);

  // optional .Impinj.STP.UserMemory user_memory = 7;
  inline bool has_user_memory() const;
  inline void clear_user_memory();
  static const int kUserMemoryFieldNumber = 7;
  inline const ::Impinj::STP::UserMemory& user_memory() const;
  inline ::Impinj::STP::UserMemory* mutable_user_memory();
  inline ::Impinj::STP::UserMemory* release_user_memory();
  inline void set_allocated_user_memory(::Impinj::STP::UserMemory* user_memory);

  // optional .Impinj.STP.Password secure_password = 8;
  inline bool has_secure_password() const;
  inline void clear_secure_password();
  static const int kSecurePasswordFieldNumber = 8;
  inline const ::Impinj::STP::Password& secure_password() const;
  inline ::Impinj::STP::Password* mutable_secure_password();
  inline ::Impinj::STP::Password* release_secure_password();
  inline void set_allocated_secure_password(::Impinj::STP::Password* secure_password);

  // optional .Impinj.STP.Password access_password = 9;
  inline bool has_access_password() const;
  inline void clear_access_password();
  static const int kAccessPasswordFieldNumber = 9;
  inline const ::Impinj::STP::Password& access_password() const;
  inline ::Impinj::STP::Password* mutable_access_password();
  inline ::Impinj::STP::Password* release_access_password();
  inline void set_allocated_access_password(::Impinj::STP::Password* access_password);

  // optional .Impinj.STP.Password kill_password = 10;
  inline bool has_kill_password() const;
  inline void clear_kill_password();
  static const int kKillPasswordFieldNumber = 10;
  inline const ::Impinj::STP::Password& kill_password() const;
  inline ::Impinj::STP::Password* mutable_kill_password();
  inline ::Impinj::STP::Password* release_kill_password();
  inline void set_allocated_kill_password(::Impinj::STP::Password* kill_password);

  // optional .Impinj.STP.LockConfig lock_config = 11;
  inline bool has_lock_config() const;
  inline void clear_lock_config();
  static const int kLockConfigFieldNumber = 11;
  inline const ::Impinj::STP::LockConfig& lock_config() const;
  inline ::Impinj::STP::LockConfig* mutable_lock_config();
  inline ::Impinj::STP::LockConfig* release_lock_config();
  inline void set_allocated_lock_config(::Impinj::STP::LockConfig* lock_config);

  // optional .Impinj.STP.BlockPermalockConfig blockpermalock_config = 12;
  inline bool has_blockpermalock_config() const;
  inline void clear_blockpermalock_config();
  static const int kBlockpermalockConfigFieldNumber = 12;
  inline const ::Impinj::STP::BlockPermalockConfig& blockpermalock_config() const;
  inline ::Impinj::STP::BlockPermalockConfig* mutable_blockpermalock_config();
  inline ::Impinj::STP::BlockPermalockConfig* release_blockpermalock_config();
  inline void set_allocated_blockpermalock_config(::Impinj::STP::BlockPermalockConfig* blockpermalock_config);

  // optional bool kill_tag = 16;
  inline bool has_kill_tag() const;
  inline void clear_kill_tag();
  static const int kKillTagFieldNumber = 16;
  inline bool kill_tag() const;
  inline void set_kill_tag(bool value);

  // optional .Impinj.STP.MonzaR6PFeatureConfig monza_r6p_feature_config = 20;
  inline bool has_monza_r6p_feature_config() const;
  inline void clear_monza_r6p_feature_config();
  static const int kMonzaR6PFeatureConfigFieldNumber = 20;
  inline const ::Impinj::STP::MonzaR6PFeatureConfig& monza_r6p_feature_config() const;
  inline ::Impinj::STP::MonzaR6PFeatureConfig* mutable_monza_r6p_feature_config();
  inline ::Impinj::STP::MonzaR6PFeatureConfig* release_monza_r6p_feature_config();
  inline void set_allocated_monza_r6p_feature_config(::Impinj::STP::MonzaR6PFeatureConfig* monza_r6p_feature_config);

  // optional .Impinj.STP.MonzaS6CFeatureConfig monza_s6c_feature_config = 21;
  inline bool has_monza_s6c_feature_config() const;
  inline void clear_monza_s6c_feature_config();
  static const int kMonzaS6CFeatureConfigFieldNumber = 21;
  inline const ::Impinj::STP::MonzaS6CFeatureConfig& monza_s6c_feature_config() const;
  inline ::Impinj::STP::MonzaS6CFeatureConfig* mutable_monza_s6c_feature_config();
  inline ::Impinj::STP::MonzaS6CFeatureConfig* release_monza_s6c_feature_config();
  inline void set_allocated_monza_s6c_feature_config(::Impinj::STP::MonzaS6CFeatureConfig* monza_s6c_feature_config);

  // optional .Impinj.STP.MonzaR6FeatureConfig monza_r6_feature_config = 22;
  inline bool has_monza_r6_feature_config() const;
  inline void clear_monza_r6_feature_config();
  static const int kMonzaR6FeatureConfigFieldNumber = 22;
  inline const ::Impinj::STP::MonzaR6FeatureConfig& monza_r6_feature_config() const;
  inline ::Impinj::STP::MonzaR6FeatureConfig* mutable_monza_r6_feature_config();
  inline ::Impinj::STP::MonzaR6FeatureConfig* release_monza_r6_feature_config();
  inline void set_allocated_monza_r6_feature_config(::Impinj::STP::MonzaR6FeatureConfig* monza_r6_feature_config);

  // optional .Impinj.STP.MonzaR6AFeatureConfig monza_r6a_feature_config = 23;
  inline bool has_monza_r6a_feature_config() const;
  inline void clear_monza_r6a_feature_config();
  static const int kMonzaR6AFeatureConfigFieldNumber = 23;
  inline const ::Impinj::STP::MonzaR6AFeatureConfig& monza_r6a_feature_config() const;
  inline ::Impinj::STP::MonzaR6AFeatureConfig* mutable_monza_r6a_feature_config();
  inline ::Impinj::STP::MonzaR6AFeatureConfig* release_monza_r6a_feature_config();
  inline void set_allocated_monza_r6a_feature_config(::Impinj::STP::MonzaR6AFeatureConfig* monza_r6a_feature_config);

  // optional uint32 TID_table_size = 17 [default = 100];
  inline bool has_tid_table_size() const;
  inline void clear_tid_table_size();
  static const int kTIDTableSizeFieldNumber = 17;
  inline ::google::protobuf::uint32 tid_table_size() const;
  inline void set_tid_table_size(::google::protobuf::uint32 value);

  // repeated .Impinj.STP.TIDTableEntry TID_table_entries = 14;
  inline int tid_table_entries_size() const;
  inline void clear_tid_table_entries();
  static const int kTIDTableEntriesFieldNumber = 14;
  inline const ::Impinj::STP::TIDTableEntry& tid_table_entries(int index) const;
  inline ::Impinj::STP::TIDTableEntry* mutable_tid_table_entries(int index);
  inline ::Impinj::STP::TIDTableEntry* add_tid_table_entries();
  inline const ::google::protobuf::RepeatedPtrField< ::Impinj::STP::TIDTableEntry >&
      tid_table_entries() const;
  inline ::google::protobuf::RepeatedPtrField< ::Impinj::STP::TIDTableEntry >*
      mutable_tid_table_entries();

  // repeated .Impinj.STP.OrderedListEntry ordered_list_entries = 15;
  inline int ordered_list_entries_size() const;
  inline void clear_ordered_list_entries();
  static const int kOrderedListEntriesFieldNumber = 15;
  inline const ::Impinj::STP::OrderedListEntry& ordered_list_entries(int index) const;
  inline ::Impinj::STP::OrderedListEntry* mutable_ordered_list_entries(int index);
  inline ::Impinj::STP::OrderedListEntry* add_ordered_list_entries();
  inline const ::google::protobuf::RepeatedPtrField< ::Impinj::STP::OrderedListEntry >&
      ordered_list_entries() const;
  inline ::google::protobuf::RepeatedPtrField< ::Impinj::STP::OrderedListEntry >*
      mutable_ordered_list_entries();

  // optional .Impinj.STP.VoidTagConfig void_tag_config = 18;
  inline bool has_void_tag_config() const;
  inline void clear_void_tag_config();
  static const int kVoidTagConfigFieldNumber = 18;
  inline const ::Impinj::STP::VoidTagConfig& void_tag_config() const;
  inline ::Impinj::STP::VoidTagConfig* mutable_void_tag_config();
  inline ::Impinj::STP::VoidTagConfig* release_void_tag_config();
  inline void set_allocated_void_tag_config(::Impinj::STP::VoidTagConfig* void_tag_config);

  // optional .Impinj.STP.SerializationJobFilters filters = 19;
  inline bool has_filters() const;
  inline void clear_filters();
  static const int kFiltersFieldNumber = 19;
  inline const ::Impinj::STP::SerializationJobFilters& filters() const;
  inline ::Impinj::STP::SerializationJobFilters* mutable_filters();
  inline ::Impinj::STP::SerializationJobFilters* release_filters();
  inline void set_allocated_filters(::Impinj::STP::SerializationJobFilters* filters);

  // @@protoc_insertion_point(class_scope:Impinj.STP.SerializationJob)
 private:
  inline void set_has_job_id();
  inline void clear_has_job_id();
  inline void set_has_job_type();
  inline void clear_has_job_type();
  inline void set_has_job_completion_criteria();
  inline void clear_has_job_completion_criteria();
  inline void set_has_operation_quantity();
  inline void clear_has_operation_quantity();
  inline void set_has_epc_memory();
  inline void clear_has_epc_memory();
  inline void set_has_tid_memory();
  inline void clear_has_tid_memory();
  inline void set_has_user_memory();
  inline void clear_has_user_memory();
  inline void set_has_secure_password();
  inline void clear_has_secure_password();
  inline void set_has_access_password();
  inline void clear_has_access_password();
  inline void set_has_kill_password();
  inline void clear_has_kill_password();
  inline void set_has_lock_config();
  inline void clear_has_lock_config();
  inline void set_has_blockpermalock_config();
  inline void clear_has_blockpermalock_config();
  inline void set_has_kill_tag();
  inline void clear_has_kill_tag();
  inline void set_has_monza_r6p_feature_config();
  inline void clear_has_monza_r6p_feature_config();
  inline void set_has_monza_s6c_feature_config();
  inline void clear_has_monza_s6c_feature_config();
  inline void set_has_monza_r6_feature_config();
  inline void clear_has_monza_r6_feature_config();
  inline void set_has_monza_r6a_feature_config();
  inline void clear_has_monza_r6a_feature_config();
  inline void set_has_tid_table_size();
  inline void clear_has_tid_table_size();
  inline void set_has_void_tag_config();
  inline void clear_has_void_tag_config();
  inline void set_has_filters();
  inline void clear_has_filters();

  ::google::protobuf::uint32 job_id_;
  int job_type_;
  int job_completion_criteria_;
  ::google::protobuf::uint32 operation_quantity_;
  ::Impinj::STP::EPCMemory* epc_memory_;
  ::Impinj::STP::TIDMemory* tid_memory_;
  ::Impinj::STP::UserMemory* user_memory_;
  ::Impinj::STP::Password* secure_password_;
  ::Impinj::STP::Password* access_password_;
  ::Impinj::STP::Password* kill_password_;
  ::Impinj::STP::LockConfig* lock_config_;
  ::Impinj::STP::BlockPermalockConfig* blockpermalock_config_;
  ::Impinj::STP::MonzaR6PFeatureConfig* monza_r6p_feature_config_;
  ::Impinj::STP::MonzaS6CFeatureConfig* monza_s6c_feature_config_;
  bool kill_tag_;
  ::google::protobuf::uint32 tid_table_size_;
  ::Impinj::STP::MonzaR6FeatureConfig* monza_r6_feature_config_;
  ::Impinj::STP::MonzaR6AFeatureConfig* monza_r6a_feature_config_;
  ::google::protobuf::RepeatedPtrField< ::Impinj::STP::TIDTableEntry > tid_table_entries_;
  ::google::protobuf::RepeatedPtrField< ::Impinj::STP::OrderedListEntry > ordered_list_entries_;
  ::Impinj::STP::VoidTagConfig* void_tag_config_;
  ::Impinj::STP::SerializationJobFilters* filters_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(22 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static SerializationJob* default_instance_;
};
// -------------------------------------------------------------------

class PCWord : public ::google::protobuf::MessageLite {
 public:
  PCWord();
  virtual ~PCWord();

  PCWord(const PCWord& from);

  inline PCWord& operator=(const PCWord& from) {
    CopyFrom(from);
    return *this;
  }

  static const PCWord& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const PCWord* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(PCWord* other);

  // implements Message ----------------------------------------------

  PCWord* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const PCWord& from);
  void MergeFrom(const PCWord& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional bytes data = 1;
  inline bool has_data() const;
  inline void clear_data();
  static const int kDataFieldNumber = 1;
  inline const ::std::string& data() const;
  inline void set_data(const ::std::string& value);
  inline void set_data(const char* value);
  inline void set_data(const void* value, size_t size);
  inline ::std::string* mutable_data();
  inline ::std::string* release_data();
  inline void set_allocated_data(::std::string* data);

  // optional bytes mask = 2;
  inline bool has_mask() const;
  inline void clear_mask();
  static const int kMaskFieldNumber = 2;
  inline const ::std::string& mask() const;
  inline void set_mask(const ::std::string& value);
  inline void set_mask(const char* value);
  inline void set_mask(const void* value, size_t size);
  inline ::std::string* mutable_mask();
  inline ::std::string* release_mask();
  inline void set_allocated_mask(::std::string* mask);

  // @@protoc_insertion_point(class_scope:Impinj.STP.PCWord)
 private:
  inline void set_has_data();
  inline void clear_has_data();
  inline void set_has_mask();
  inline void clear_has_mask();

  ::std::string* data_;
  ::std::string* mask_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static PCWord* default_instance_;
};
// -------------------------------------------------------------------

class EPCMemory : public ::google::protobuf::MessageLite {
 public:
  EPCMemory();
  virtual ~EPCMemory();

  EPCMemory(const EPCMemory& from);

  inline EPCMemory& operator=(const EPCMemory& from) {
    CopyFrom(from);
    return *this;
  }

  static const EPCMemory& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const EPCMemory* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(EPCMemory* other);

  // implements Message ----------------------------------------------

  EPCMemory* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const EPCMemory& from);
  void MergeFrom(const EPCMemory& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional bytes data = 1;
  inline bool has_data() const;
  inline void clear_data();
  static const int kDataFieldNumber = 1;
  inline const ::std::string& data() const;
  inline void set_data(const ::std::string& value);
  inline void set_data(const char* value);
  inline void set_data(const void* value, size_t size);
  inline ::std::string* mutable_data();
  inline ::std::string* release_data();
  inline void set_allocated_data(::std::string* data);

  // optional bytes mask = 2;
  inline bool has_mask() const;
  inline void clear_mask();
  static const int kMaskFieldNumber = 2;
  inline const ::std::string& mask() const;
  inline void set_mask(const ::std::string& value);
  inline void set_mask(const char* value);
  inline void set_mask(const void* value, size_t size);
  inline ::std::string* mutable_mask();
  inline ::std::string* release_mask();
  inline void set_allocated_mask(::std::string* mask);

  // optional .Impinj.STP.Serialization serialization = 3;
  inline bool has_serialization() const;
  inline void clear_serialization();
  static const int kSerializationFieldNumber = 3;
  inline const ::Impinj::STP::Serialization& serialization() const;
  inline ::Impinj::STP::Serialization* mutable_serialization();
  inline ::Impinj::STP::Serialization* release_serialization();
  inline void set_allocated_serialization(::Impinj::STP::Serialization* serialization);

  // optional .Impinj.STP.PCWord pc_word = 4;
  inline bool has_pc_word() const;
  inline void clear_pc_word();
  static const int kPcWordFieldNumber = 4;
  inline const ::Impinj::STP::PCWord& pc_word() const;
  inline ::Impinj::STP::PCWord* mutable_pc_word();
  inline ::Impinj::STP::PCWord* release_pc_word();
  inline void set_allocated_pc_word(::Impinj::STP::PCWord* pc_word);

  // @@protoc_insertion_point(class_scope:Impinj.STP.EPCMemory)
 private:
  inline void set_has_data();
  inline void clear_has_data();
  inline void set_has_mask();
  inline void clear_has_mask();
  inline void set_has_serialization();
  inline void clear_has_serialization();
  inline void set_has_pc_word();
  inline void clear_has_pc_word();

  ::std::string* data_;
  ::std::string* mask_;
  ::Impinj::STP::Serialization* serialization_;
  ::Impinj::STP::PCWord* pc_word_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static EPCMemory* default_instance_;
};
// -------------------------------------------------------------------

class TIDMemory : public ::google::protobuf::MessageLite {
 public:
  TIDMemory();
  virtual ~TIDMemory();

  TIDMemory(const TIDMemory& from);

  inline TIDMemory& operator=(const TIDMemory& from) {
    CopyFrom(from);
    return *this;
  }

  static const TIDMemory& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const TIDMemory* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(TIDMemory* other);

  // implements Message ----------------------------------------------

  TIDMemory* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const TIDMemory& from);
  void MergeFrom(const TIDMemory& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // required bytes data = 1;
  inline bool has_data() const;
  inline void clear_data();
  static const int kDataFieldNumber = 1;
  inline const ::std::string& data() const;
  inline void set_data(const ::std::string& value);
  inline void set_data(const char* value);
  inline void set_data(const void* value, size_t size);
  inline ::std::string* mutable_data();
  inline ::std::string* release_data();
  inline void set_allocated_data(::std::string* data);

  // optional uint32 word_offset = 3 [default = 0];
  inline bool has_word_offset() const;
  inline void clear_word_offset();
  static const int kWordOffsetFieldNumber = 3;
  inline ::google::protobuf::uint32 word_offset() const;
  inline void set_word_offset(::google::protobuf::uint32 value);

  // @@protoc_insertion_point(class_scope:Impinj.STP.TIDMemory)
 private:
  inline void set_has_data();
  inline void clear_has_data();
  inline void set_has_word_offset();
  inline void clear_has_word_offset();

  ::std::string* data_;
  ::google::protobuf::uint32 word_offset_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static TIDMemory* default_instance_;
};
// -------------------------------------------------------------------

class Serialization : public ::google::protobuf::MessageLite {
 public:
  Serialization();
  virtual ~Serialization();

  Serialization(const Serialization& from);

  inline Serialization& operator=(const Serialization& from) {
    CopyFrom(from);
    return *this;
  }

  static const Serialization& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const Serialization* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(Serialization* other);

  // implements Message ----------------------------------------------

  Serialization* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const Serialization& from);
  void MergeFrom(const Serialization& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // required uint32 serialization_bits = 1;
  inline bool has_serialization_bits() const;
  inline void clear_serialization_bits();
  static const int kSerializationBitsFieldNumber = 1;
  inline ::google::protobuf::uint32 serialization_bits() const;
  inline void set_serialization_bits(::google::protobuf::uint32 value);

  // optional .Impinj.STP.MonzaSelfSerialization monza_self_serialization = 6;
  inline bool has_monza_self_serialization() const;
  inline void clear_monza_self_serialization();
  static const int kMonzaSelfSerializationFieldNumber = 6;
  inline const ::Impinj::STP::MonzaSelfSerialization& monza_self_serialization() const;
  inline ::Impinj::STP::MonzaSelfSerialization* mutable_monza_self_serialization();
  inline ::Impinj::STP::MonzaSelfSerialization* release_monza_self_serialization();
  inline void set_allocated_monza_self_serialization(::Impinj::STP::MonzaSelfSerialization* monza_self_serialization);

  // optional .Impinj.STP.SerialNumberRange serial_number_range = 7;
  inline bool has_serial_number_range() const;
  inline void clear_serial_number_range();
  static const int kSerialNumberRangeFieldNumber = 7;
  inline const ::Impinj::STP::SerialNumberRange& serial_number_range() const;
  inline ::Impinj::STP::SerialNumberRange* mutable_serial_number_range();
  inline ::Impinj::STP::SerialNumberRange* release_serial_number_range();
  inline void set_allocated_serial_number_range(::Impinj::STP::SerialNumberRange* serial_number_range);

  // @@protoc_insertion_point(class_scope:Impinj.STP.Serialization)
 private:
  inline void set_has_serialization_bits();
  inline void clear_has_serialization_bits();
  inline void set_has_monza_self_serialization();
  inline void clear_has_monza_self_serialization();
  inline void set_has_serial_number_range();
  inline void clear_has_serial_number_range();

  ::Impinj::STP::MonzaSelfSerialization* monza_self_serialization_;
  ::Impinj::STP::SerialNumberRange* serial_number_range_;
  ::google::protobuf::uint32 serialization_bits_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static Serialization* default_instance_;
};
// -------------------------------------------------------------------

class MonzaSelfSerialization : public ::google::protobuf::MessageLite {
 public:
  MonzaSelfSerialization();
  virtual ~MonzaSelfSerialization();

  MonzaSelfSerialization(const MonzaSelfSerialization& from);

  inline MonzaSelfSerialization& operator=(const MonzaSelfSerialization& from) {
    CopyFrom(from);
    return *this;
  }

  static const MonzaSelfSerialization& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const MonzaSelfSerialization* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(MonzaSelfSerialization* other);

  // implements Message ----------------------------------------------

  MonzaSelfSerialization* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const MonzaSelfSerialization& from);
  void MergeFrom(const MonzaSelfSerialization& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional string serialization_prefix = 1;
  inline bool has_serialization_prefix() const;
  inline void clear_serialization_prefix();
  static const int kSerializationPrefixFieldNumber = 1;
  inline const ::std::string& serialization_prefix() const;
  inline void set_serialization_prefix(const ::std::string& value);
  inline void set_serialization_prefix(const char* value);
  inline void set_serialization_prefix(const char* value, size_t size);
  inline ::std::string* mutable_serialization_prefix();
  inline ::std::string* release_serialization_prefix();
  inline void set_allocated_serialization_prefix(::std::string* serialization_prefix);

  // @@protoc_insertion_point(class_scope:Impinj.STP.MonzaSelfSerialization)
 private:
  inline void set_has_serialization_prefix();
  inline void clear_has_serialization_prefix();

  ::std::string* serialization_prefix_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static MonzaSelfSerialization* default_instance_;
};
// -------------------------------------------------------------------

class SerialNumberRange : public ::google::protobuf::MessageLite {
 public:
  SerialNumberRange();
  virtual ~SerialNumberRange();

  SerialNumberRange(const SerialNumberRange& from);

  inline SerialNumberRange& operator=(const SerialNumberRange& from) {
    CopyFrom(from);
    return *this;
  }

  static const SerialNumberRange& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const SerialNumberRange* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(SerialNumberRange* other);

  // implements Message ----------------------------------------------

  SerialNumberRange* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const SerialNumberRange& from);
  void MergeFrom(const SerialNumberRange& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional uint64 serial_number_range_start = 1;
  inline bool has_serial_number_range_start() const;
  inline void clear_serial_number_range_start();
  static const int kSerialNumberRangeStartFieldNumber = 1;
  inline ::google::protobuf::uint64 serial_number_range_start() const;
  inline void set_serial_number_range_start(::google::protobuf::uint64 value);

  // optional uint64 serial_number_range_end = 2;
  inline bool has_serial_number_range_end() const;
  inline void clear_serial_number_range_end();
  static const int kSerialNumberRangeEndFieldNumber = 2;
  inline ::google::protobuf::uint64 serial_number_range_end() const;
  inline void set_serial_number_range_end(::google::protobuf::uint64 value);

  // optional uint32 bit_offset = 3;
  inline bool has_bit_offset() const;
  inline void clear_bit_offset();
  static const int kBitOffsetFieldNumber = 3;
  inline ::google::protobuf::uint32 bit_offset() const;
  inline void set_bit_offset(::google::protobuf::uint32 value);

  // optional .Impinj.STP.SerialNumberRangeFormat serial_number_range_format = 4;
  inline bool has_serial_number_range_format() const;
  inline void clear_serial_number_range_format();
  static const int kSerialNumberRangeFormatFieldNumber = 4;
  inline ::Impinj::STP::SerialNumberRangeFormat serial_number_range_format() const;
  inline void set_serial_number_range_format(::Impinj::STP::SerialNumberRangeFormat value);

  // @@protoc_insertion_point(class_scope:Impinj.STP.SerialNumberRange)
 private:
  inline void set_has_serial_number_range_start();
  inline void clear_has_serial_number_range_start();
  inline void set_has_serial_number_range_end();
  inline void clear_has_serial_number_range_end();
  inline void set_has_bit_offset();
  inline void clear_has_bit_offset();
  inline void set_has_serial_number_range_format();
  inline void clear_has_serial_number_range_format();

  ::google::protobuf::uint64 serial_number_range_start_;
  ::google::protobuf::uint64 serial_number_range_end_;
  ::google::protobuf::uint32 bit_offset_;
  int serial_number_range_format_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static SerialNumberRange* default_instance_;
};
// -------------------------------------------------------------------

class UserMemory : public ::google::protobuf::MessageLite {
 public:
  UserMemory();
  virtual ~UserMemory();

  UserMemory(const UserMemory& from);

  inline UserMemory& operator=(const UserMemory& from) {
    CopyFrom(from);
    return *this;
  }

  static const UserMemory& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const UserMemory* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(UserMemory* other);

  // implements Message ----------------------------------------------

  UserMemory* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const UserMemory& from);
  void MergeFrom(const UserMemory& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional bytes data = 1;
  inline bool has_data() const;
  inline void clear_data();
  static const int kDataFieldNumber = 1;
  inline const ::std::string& data() const;
  inline void set_data(const ::std::string& value);
  inline void set_data(const char* value);
  inline void set_data(const void* value, size_t size);
  inline ::std::string* mutable_data();
  inline ::std::string* release_data();
  inline void set_allocated_data(::std::string* data);

  // optional bytes mask = 2;
  inline bool has_mask() const;
  inline void clear_mask();
  static const int kMaskFieldNumber = 2;
  inline const ::std::string& mask() const;
  inline void set_mask(const ::std::string& value);
  inline void set_mask(const char* value);
  inline void set_mask(const void* value, size_t size);
  inline ::std::string* mutable_mask();
  inline ::std::string* release_mask();
  inline void set_allocated_mask(::std::string* mask);

  // optional uint32 word_offset = 3 [default = 0];
  inline bool has_word_offset() const;
  inline void clear_word_offset();
  static const int kWordOffsetFieldNumber = 3;
  inline ::google::protobuf::uint32 word_offset() const;
  inline void set_word_offset(::google::protobuf::uint32 value);

  // optional uint32 word_count_inv = 4 [default = 0];
  inline bool has_word_count_inv() const;
  inline void clear_word_count_inv();
  static const int kWordCountInvFieldNumber = 4;
  inline ::google::protobuf::uint32 word_count_inv() const;
  inline void set_word_count_inv(::google::protobuf::uint32 value);

  // @@protoc_insertion_point(class_scope:Impinj.STP.UserMemory)
 private:
  inline void set_has_data();
  inline void clear_has_data();
  inline void set_has_mask();
  inline void clear_has_mask();
  inline void set_has_word_offset();
  inline void clear_has_word_offset();
  inline void set_has_word_count_inv();
  inline void clear_has_word_count_inv();

  ::std::string* data_;
  ::std::string* mask_;
  ::google::protobuf::uint32 word_offset_;
  ::google::protobuf::uint32 word_count_inv_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static UserMemory* default_instance_;
};
// -------------------------------------------------------------------

class Password : public ::google::protobuf::MessageLite {
 public:
  Password();
  virtual ~Password();

  Password(const Password& from);

  inline Password& operator=(const Password& from) {
    CopyFrom(from);
    return *this;
  }

  static const Password& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const Password* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(Password* other);

  // implements Message ----------------------------------------------

  Password* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const Password& from);
  void MergeFrom(const Password& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .Impinj.STP.PasswordGenerationMethod password_generation_method = 1 [default = PASSWORD_GENERATION_METHOD_STATIC];
  inline bool has_password_generation_method() const;
  inline void clear_password_generation_method();
  static const int kPasswordGenerationMethodFieldNumber = 1;
  inline ::Impinj::STP::PasswordGenerationMethod password_generation_method() const;
  inline void set_password_generation_method(::Impinj::STP::PasswordGenerationMethod value);

  // required bytes data = 2;
  inline bool has_data() const;
  inline void clear_data();
  static const int kDataFieldNumber = 2;
  inline const ::std::string& data() const;
  inline void set_data(const ::std::string& value);
  inline void set_data(const char* value);
  inline void set_data(const void* value, size_t size);
  inline ::std::string* mutable_data();
  inline ::std::string* release_data();
  inline void set_allocated_data(::std::string* data);

  // @@protoc_insertion_point(class_scope:Impinj.STP.Password)
 private:
  inline void set_has_password_generation_method();
  inline void clear_has_password_generation_method();
  inline void set_has_data();
  inline void clear_has_data();

  ::std::string* data_;
  int password_generation_method_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static Password* default_instance_;
};
// -------------------------------------------------------------------

class LockConfig : public ::google::protobuf::MessageLite {
 public:
  LockConfig();
  virtual ~LockConfig();

  LockConfig(const LockConfig& from);

  inline LockConfig& operator=(const LockConfig& from) {
    CopyFrom(from);
    return *this;
  }

  static const LockConfig& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const LockConfig* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(LockConfig* other);

  // implements Message ----------------------------------------------

  LockConfig* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const LockConfig& from);
  void MergeFrom(const LockConfig& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // required bytes lock_config_payload = 1;
  inline bool has_lock_config_payload() const;
  inline void clear_lock_config_payload();
  static const int kLockConfigPayloadFieldNumber = 1;
  inline const ::std::string& lock_config_payload() const;
  inline void set_lock_config_payload(const ::std::string& value);
  inline void set_lock_config_payload(const char* value);
  inline void set_lock_config_payload(const void* value, size_t size);
  inline ::std::string* mutable_lock_config_payload();
  inline ::std::string* release_lock_config_payload();
  inline void set_allocated_lock_config_payload(::std::string* lock_config_payload);

  // @@protoc_insertion_point(class_scope:Impinj.STP.LockConfig)
 private:
  inline void set_has_lock_config_payload();
  inline void clear_has_lock_config_payload();

  ::std::string* lock_config_payload_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static LockConfig* default_instance_;
};
// -------------------------------------------------------------------

class BlockPermalockConfig : public ::google::protobuf::MessageLite {
 public:
  BlockPermalockConfig();
  virtual ~BlockPermalockConfig();

  BlockPermalockConfig(const BlockPermalockConfig& from);

  inline BlockPermalockConfig& operator=(const BlockPermalockConfig& from) {
    CopyFrom(from);
    return *this;
  }

  static const BlockPermalockConfig& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const BlockPermalockConfig* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(BlockPermalockConfig* other);

  // implements Message ----------------------------------------------

  BlockPermalockConfig* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const BlockPermalockConfig& from);
  void MergeFrom(const BlockPermalockConfig& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // required uint32 block_pointer = 1;
  inline bool has_block_pointer() const;
  inline void clear_block_pointer();
  static const int kBlockPointerFieldNumber = 1;
  inline ::google::protobuf::uint32 block_pointer() const;
  inline void set_block_pointer(::google::protobuf::uint32 value);

  // required bytes block_mask = 2;
  inline bool has_block_mask() const;
  inline void clear_block_mask();
  static const int kBlockMaskFieldNumber = 2;
  inline const ::std::string& block_mask() const;
  inline void set_block_mask(const ::std::string& value);
  inline void set_block_mask(const char* value);
  inline void set_block_mask(const void* value, size_t size);
  inline ::std::string* mutable_block_mask();
  inline ::std::string* release_block_mask();
  inline void set_allocated_block_mask(::std::string* block_mask);

  // @@protoc_insertion_point(class_scope:Impinj.STP.BlockPermalockConfig)
 private:
  inline void set_has_block_pointer();
  inline void clear_has_block_pointer();
  inline void set_has_block_mask();
  inline void clear_has_block_mask();

  ::std::string* block_mask_;
  ::google::protobuf::uint32 block_pointer_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static BlockPermalockConfig* default_instance_;
};
// -------------------------------------------------------------------

class MonzaR6PFeatureConfig : public ::google::protobuf::MessageLite {
 public:
  MonzaR6PFeatureConfig();
  virtual ~MonzaR6PFeatureConfig();

  MonzaR6PFeatureConfig(const MonzaR6PFeatureConfig& from);

  inline MonzaR6PFeatureConfig& operator=(const MonzaR6PFeatureConfig& from) {
    CopyFrom(from);
    return *this;
  }

  static const MonzaR6PFeatureConfig& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const MonzaR6PFeatureConfig* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(MonzaR6PFeatureConfig* other);

  // implements Message ----------------------------------------------

  MonzaR6PFeatureConfig* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const MonzaR6PFeatureConfig& from);
  void MergeFrom(const MonzaR6PFeatureConfig& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional bool enable_auto_tune = 1;
  inline bool has_enable_auto_tune() const;
  inline void clear_enable_auto_tune();
  static const int kEnableAutoTuneFieldNumber = 1;
  inline bool enable_auto_tune() const;
  inline void set_enable_auto_tune(bool value);

  // optional bool enable_short_range_mode = 2;
  inline bool has_enable_short_range_mode() const;
  inline void clear_enable_short_range_mode();
  static const int kEnableShortRangeModeFieldNumber = 2;
  inline bool enable_short_range_mode() const;
  inline void set_enable_short_range_mode(bool value);

  // optional .Impinj.STP.MonzaR6PMemoryMapConfig memory_map_config = 4;
  inline bool has_memory_map_config() const;
  inline void clear_memory_map_config();
  static const int kMemoryMapConfigFieldNumber = 4;
  inline ::Impinj::STP::MonzaR6PMemoryMapConfig memory_map_config() const;
  inline void set_memory_map_config(::Impinj::STP::MonzaR6PMemoryMapConfig value);

  // @@protoc_insertion_point(class_scope:Impinj.STP.MonzaR6PFeatureConfig)
 private:
  inline void set_has_enable_auto_tune();
  inline void clear_has_enable_auto_tune();
  inline void set_has_enable_short_range_mode();
  inline void clear_has_enable_short_range_mode();
  inline void set_has_memory_map_config();
  inline void clear_has_memory_map_config();

  bool enable_auto_tune_;
  bool enable_short_range_mode_;
  int memory_map_config_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static MonzaR6PFeatureConfig* default_instance_;
};
// -------------------------------------------------------------------

class MonzaS6CFeatureConfig : public ::google::protobuf::MessageLite {
 public:
  MonzaS6CFeatureConfig();
  virtual ~MonzaS6CFeatureConfig();

  MonzaS6CFeatureConfig(const MonzaS6CFeatureConfig& from);

  inline MonzaS6CFeatureConfig& operator=(const MonzaS6CFeatureConfig& from) {
    CopyFrom(from);
    return *this;
  }

  static const MonzaS6CFeatureConfig& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const MonzaS6CFeatureConfig* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(MonzaS6CFeatureConfig* other);

  // implements Message ----------------------------------------------

  MonzaS6CFeatureConfig* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const MonzaS6CFeatureConfig& from);
  void MergeFrom(const MonzaS6CFeatureConfig& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional bool enable_auto_tune = 1;
  inline bool has_enable_auto_tune() const;
  inline void clear_enable_auto_tune();
  static const int kEnableAutoTuneFieldNumber = 1;
  inline bool enable_auto_tune() const;
  inline void set_enable_auto_tune(bool value);

  // optional bool enable_short_range_mode = 2;
  inline bool has_enable_short_range_mode() const;
  inline void clear_enable_short_range_mode();
  static const int kEnableShortRangeModeFieldNumber = 2;
  inline bool enable_short_range_mode() const;
  inline void set_enable_short_range_mode(bool value);

  // @@protoc_insertion_point(class_scope:Impinj.STP.MonzaS6CFeatureConfig)
 private:
  inline void set_has_enable_auto_tune();
  inline void clear_has_enable_auto_tune();
  inline void set_has_enable_short_range_mode();
  inline void clear_has_enable_short_range_mode();

  bool enable_auto_tune_;
  bool enable_short_range_mode_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static MonzaS6CFeatureConfig* default_instance_;
};
// -------------------------------------------------------------------

class MonzaR6FeatureConfig : public ::google::protobuf::MessageLite {
 public:
  MonzaR6FeatureConfig();
  virtual ~MonzaR6FeatureConfig();

  MonzaR6FeatureConfig(const MonzaR6FeatureConfig& from);

  inline MonzaR6FeatureConfig& operator=(const MonzaR6FeatureConfig& from) {
    CopyFrom(from);
    return *this;
  }

  static const MonzaR6FeatureConfig& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const MonzaR6FeatureConfig* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(MonzaR6FeatureConfig* other);

  // implements Message ----------------------------------------------

  MonzaR6FeatureConfig* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const MonzaR6FeatureConfig& from);
  void MergeFrom(const MonzaR6FeatureConfig& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional bool enable_auto_tune = 1;
  inline bool has_enable_auto_tune() const;
  inline void clear_enable_auto_tune();
  static const int kEnableAutoTuneFieldNumber = 1;
  inline bool enable_auto_tune() const;
  inline void set_enable_auto_tune(bool value);

  // @@protoc_insertion_point(class_scope:Impinj.STP.MonzaR6FeatureConfig)
 private:
  inline void set_has_enable_auto_tune();
  inline void clear_has_enable_auto_tune();

  bool enable_auto_tune_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static MonzaR6FeatureConfig* default_instance_;
};
// -------------------------------------------------------------------

class MonzaR6AFeatureConfig : public ::google::protobuf::MessageLite {
 public:
  MonzaR6AFeatureConfig();
  virtual ~MonzaR6AFeatureConfig();

  MonzaR6AFeatureConfig(const MonzaR6AFeatureConfig& from);

  inline MonzaR6AFeatureConfig& operator=(const MonzaR6AFeatureConfig& from) {
    CopyFrom(from);
    return *this;
  }

  static const MonzaR6AFeatureConfig& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const MonzaR6AFeatureConfig* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(MonzaR6AFeatureConfig* other);

  // implements Message ----------------------------------------------

  MonzaR6AFeatureConfig* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const MonzaR6AFeatureConfig& from);
  void MergeFrom(const MonzaR6AFeatureConfig& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional bool enable_auto_tune = 1;
  inline bool has_enable_auto_tune() const;
  inline void clear_enable_auto_tune();
  static const int kEnableAutoTuneFieldNumber = 1;
  inline bool enable_auto_tune() const;
  inline void set_enable_auto_tune(bool value);

  // optional bool enable_short_range_mode = 2;
  inline bool has_enable_short_range_mode() const;
  inline void clear_enable_short_range_mode();
  static const int kEnableShortRangeModeFieldNumber = 2;
  inline bool enable_short_range_mode() const;
  inline void set_enable_short_range_mode(bool value);

  // @@protoc_insertion_point(class_scope:Impinj.STP.MonzaR6AFeatureConfig)
 private:
  inline void set_has_enable_auto_tune();
  inline void clear_has_enable_auto_tune();
  inline void set_has_enable_short_range_mode();
  inline void clear_has_enable_short_range_mode();

  bool enable_auto_tune_;
  bool enable_short_range_mode_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static MonzaR6AFeatureConfig* default_instance_;
};
// -------------------------------------------------------------------

class TIDTableEntry : public ::google::protobuf::MessageLite {
 public:
  TIDTableEntry();
  virtual ~TIDTableEntry();

  TIDTableEntry(const TIDTableEntry& from);

  inline TIDTableEntry& operator=(const TIDTableEntry& from) {
    CopyFrom(from);
    return *this;
  }

  static const TIDTableEntry& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const TIDTableEntry* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(TIDTableEntry* other);

  // implements Message ----------------------------------------------

  TIDTableEntry* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const TIDTableEntry& from);
  void MergeFrom(const TIDTableEntry& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // required bytes TID = 1;
  inline bool has_tid() const;
  inline void clear_tid();
  static const int kTIDFieldNumber = 1;
  inline const ::std::string& tid() const;
  inline void set_tid(const ::std::string& value);
  inline void set_tid(const char* value);
  inline void set_tid(const void* value, size_t size);
  inline ::std::string* mutable_tid();
  inline ::std::string* release_tid();
  inline void set_allocated_tid(::std::string* tid);

  // optional .Impinj.STP.EPCMemory EPC_memory = 3;
  inline bool has_epc_memory() const;
  inline void clear_epc_memory();
  static const int kEPCMemoryFieldNumber = 3;
  inline const ::Impinj::STP::EPCMemory& epc_memory() const;
  inline ::Impinj::STP::EPCMemory* mutable_epc_memory();
  inline ::Impinj::STP::EPCMemory* release_epc_memory();
  inline void set_allocated_epc_memory(::Impinj::STP::EPCMemory* epc_memory);

  // optional .Impinj.STP.TIDMemory TID_memory = 4;
  inline bool has_tid_memory() const;
  inline void clear_tid_memory();
  static const int kTIDMemoryFieldNumber = 4;
  inline const ::Impinj::STP::TIDMemory& tid_memory() const;
  inline ::Impinj::STP::TIDMemory* mutable_tid_memory();
  inline ::Impinj::STP::TIDMemory* release_tid_memory();
  inline void set_allocated_tid_memory(::Impinj::STP::TIDMemory* tid_memory);

  // optional .Impinj.STP.UserMemory user_memory = 5;
  inline bool has_user_memory() const;
  inline void clear_user_memory();
  static const int kUserMemoryFieldNumber = 5;
  inline const ::Impinj::STP::UserMemory& user_memory() const;
  inline ::Impinj::STP::UserMemory* mutable_user_memory();
  inline ::Impinj::STP::UserMemory* release_user_memory();
  inline void set_allocated_user_memory(::Impinj::STP::UserMemory* user_memory);

  // optional .Impinj.STP.Password secure_password = 6;
  inline bool has_secure_password() const;
  inline void clear_secure_password();
  static const int kSecurePasswordFieldNumber = 6;
  inline const ::Impinj::STP::Password& secure_password() const;
  inline ::Impinj::STP::Password* mutable_secure_password();
  inline ::Impinj::STP::Password* release_secure_password();
  inline void set_allocated_secure_password(::Impinj::STP::Password* secure_password);

  // optional .Impinj.STP.Password access_password = 7;
  inline bool has_access_password() const;
  inline void clear_access_password();
  static const int kAccessPasswordFieldNumber = 7;
  inline const ::Impinj::STP::Password& access_password() const;
  inline ::Impinj::STP::Password* mutable_access_password();
  inline ::Impinj::STP::Password* release_access_password();
  inline void set_allocated_access_password(::Impinj::STP::Password* access_password);

  // optional .Impinj.STP.Password kill_password = 8;
  inline bool has_kill_password() const;
  inline void clear_kill_password();
  static const int kKillPasswordFieldNumber = 8;
  inline const ::Impinj::STP::Password& kill_password() const;
  inline ::Impinj::STP::Password* mutable_kill_password();
  inline ::Impinj::STP::Password* release_kill_password();
  inline void set_allocated_kill_password(::Impinj::STP::Password* kill_password);

  // optional .Impinj.STP.LockConfig lock_config = 9;
  inline bool has_lock_config() const;
  inline void clear_lock_config();
  static const int kLockConfigFieldNumber = 9;
  inline const ::Impinj::STP::LockConfig& lock_config() const;
  inline ::Impinj::STP::LockConfig* mutable_lock_config();
  inline ::Impinj::STP::LockConfig* release_lock_config();
  inline void set_allocated_lock_config(::Impinj::STP::LockConfig* lock_config);

  // optional .Impinj.STP.BlockPermalockConfig blockpermalock_config = 10;
  inline bool has_blockpermalock_config() const;
  inline void clear_blockpermalock_config();
  static const int kBlockpermalockConfigFieldNumber = 10;
  inline const ::Impinj::STP::BlockPermalockConfig& blockpermalock_config() const;
  inline ::Impinj::STP::BlockPermalockConfig* mutable_blockpermalock_config();
  inline ::Impinj::STP::BlockPermalockConfig* release_blockpermalock_config();
  inline void set_allocated_blockpermalock_config(::Impinj::STP::BlockPermalockConfig* blockpermalock_config);

  // optional bool kill_tag = 12;
  inline bool has_kill_tag() const;
  inline void clear_kill_tag();
  static const int kKillTagFieldNumber = 12;
  inline bool kill_tag() const;
  inline void set_kill_tag(bool value);

  // optional bool void_tag = 13;
  inline bool has_void_tag() const;
  inline void clear_void_tag();
  static const int kVoidTagFieldNumber = 13;
  inline bool void_tag() const;
  inline void set_void_tag(bool value);

  // optional .Impinj.STP.MonzaR6PFeatureConfig monza_r6p_feature_config = 14;
  inline bool has_monza_r6p_feature_config() const;
  inline void clear_monza_r6p_feature_config();
  static const int kMonzaR6PFeatureConfigFieldNumber = 14;
  inline const ::Impinj::STP::MonzaR6PFeatureConfig& monza_r6p_feature_config() const;
  inline ::Impinj::STP::MonzaR6PFeatureConfig* mutable_monza_r6p_feature_config();
  inline ::Impinj::STP::MonzaR6PFeatureConfig* release_monza_r6p_feature_config();
  inline void set_allocated_monza_r6p_feature_config(::Impinj::STP::MonzaR6PFeatureConfig* monza_r6p_feature_config);

  // optional .Impinj.STP.MonzaS6CFeatureConfig monza_s6c_feature_config = 15;
  inline bool has_monza_s6c_feature_config() const;
  inline void clear_monza_s6c_feature_config();
  static const int kMonzaS6CFeatureConfigFieldNumber = 15;
  inline const ::Impinj::STP::MonzaS6CFeatureConfig& monza_s6c_feature_config() const;
  inline ::Impinj::STP::MonzaS6CFeatureConfig* mutable_monza_s6c_feature_config();
  inline ::Impinj::STP::MonzaS6CFeatureConfig* release_monza_s6c_feature_config();
  inline void set_allocated_monza_s6c_feature_config(::Impinj::STP::MonzaS6CFeatureConfig* monza_s6c_feature_config);

  // optional .Impinj.STP.MonzaR6FeatureConfig monza_r6_feature_config = 16;
  inline bool has_monza_r6_feature_config() const;
  inline void clear_monza_r6_feature_config();
  static const int kMonzaR6FeatureConfigFieldNumber = 16;
  inline const ::Impinj::STP::MonzaR6FeatureConfig& monza_r6_feature_config() const;
  inline ::Impinj::STP::MonzaR6FeatureConfig* mutable_monza_r6_feature_config();
  inline ::Impinj::STP::MonzaR6FeatureConfig* release_monza_r6_feature_config();
  inline void set_allocated_monza_r6_feature_config(::Impinj::STP::MonzaR6FeatureConfig* monza_r6_feature_config);

  // optional .Impinj.STP.MonzaR6AFeatureConfig monza_r6a_feature_config = 17;
  inline bool has_monza_r6a_feature_config() const;
  inline void clear_monza_r6a_feature_config();
  static const int kMonzaR6AFeatureConfigFieldNumber = 17;
  inline const ::Impinj::STP::MonzaR6AFeatureConfig& monza_r6a_feature_config() const;
  inline ::Impinj::STP::MonzaR6AFeatureConfig* mutable_monza_r6a_feature_config();
  inline ::Impinj::STP::MonzaR6AFeatureConfig* release_monza_r6a_feature_config();
  inline void set_allocated_monza_r6a_feature_config(::Impinj::STP::MonzaR6AFeatureConfig* monza_r6a_feature_config);

  // @@protoc_insertion_point(class_scope:Impinj.STP.TIDTableEntry)
 private:
  inline void set_has_tid();
  inline void clear_has_tid();
  inline void set_has_epc_memory();
  inline void clear_has_epc_memory();
  inline void set_has_tid_memory();
  inline void clear_has_tid_memory();
  inline void set_has_user_memory();
  inline void clear_has_user_memory();
  inline void set_has_secure_password();
  inline void clear_has_secure_password();
  inline void set_has_access_password();
  inline void clear_has_access_password();
  inline void set_has_kill_password();
  inline void clear_has_kill_password();
  inline void set_has_lock_config();
  inline void clear_has_lock_config();
  inline void set_has_blockpermalock_config();
  inline void clear_has_blockpermalock_config();
  inline void set_has_kill_tag();
  inline void clear_has_kill_tag();
  inline void set_has_void_tag();
  inline void clear_has_void_tag();
  inline void set_has_monza_r6p_feature_config();
  inline void clear_has_monza_r6p_feature_config();
  inline void set_has_monza_s6c_feature_config();
  inline void clear_has_monza_s6c_feature_config();
  inline void set_has_monza_r6_feature_config();
  inline void clear_has_monza_r6_feature_config();
  inline void set_has_monza_r6a_feature_config();
  inline void clear_has_monza_r6a_feature_config();

  ::std::string* tid_;
  ::Impinj::STP::EPCMemory* epc_memory_;
  ::Impinj::STP::TIDMemory* tid_memory_;
  ::Impinj::STP::UserMemory* user_memory_;
  ::Impinj::STP::Password* secure_password_;
  ::Impinj::STP::Password* access_password_;
  ::Impinj::STP::Password* kill_password_;
  ::Impinj::STP::LockConfig* lock_config_;
  ::Impinj::STP::BlockPermalockConfig* blockpermalock_config_;
  ::Impinj::STP::MonzaR6PFeatureConfig* monza_r6p_feature_config_;
  ::Impinj::STP::MonzaS6CFeatureConfig* monza_s6c_feature_config_;
  ::Impinj::STP::MonzaR6FeatureConfig* monza_r6_feature_config_;
  ::Impinj::STP::MonzaR6AFeatureConfig* monza_r6a_feature_config_;
  bool kill_tag_;
  bool void_tag_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(15 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static TIDTableEntry* default_instance_;
};
// -------------------------------------------------------------------

class TIDTableEntries : public ::google::protobuf::MessageLite {
 public:
  TIDTableEntries();
  virtual ~TIDTableEntries();

  TIDTableEntries(const TIDTableEntries& from);

  inline TIDTableEntries& operator=(const TIDTableEntries& from) {
    CopyFrom(from);
    return *this;
  }

  static const TIDTableEntries& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const TIDTableEntries* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(TIDTableEntries* other);

  // implements Message ----------------------------------------------

  TIDTableEntries* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const TIDTableEntries& from);
  void MergeFrom(const TIDTableEntries& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated .Impinj.STP.TIDTableEntry tid_table_entries = 1;
  inline int tid_table_entries_size() const;
  inline void clear_tid_table_entries();
  static const int kTidTableEntriesFieldNumber = 1;
  inline const ::Impinj::STP::TIDTableEntry& tid_table_entries(int index) const;
  inline ::Impinj::STP::TIDTableEntry* mutable_tid_table_entries(int index);
  inline ::Impinj::STP::TIDTableEntry* add_tid_table_entries();
  inline const ::google::protobuf::RepeatedPtrField< ::Impinj::STP::TIDTableEntry >&
      tid_table_entries() const;
  inline ::google::protobuf::RepeatedPtrField< ::Impinj::STP::TIDTableEntry >*
      mutable_tid_table_entries();

  // @@protoc_insertion_point(class_scope:Impinj.STP.TIDTableEntries)
 private:

  ::google::protobuf::RepeatedPtrField< ::Impinj::STP::TIDTableEntry > tid_table_entries_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static TIDTableEntries* default_instance_;
};
// -------------------------------------------------------------------

class OrderedListEntry : public ::google::protobuf::MessageLite {
 public:
  OrderedListEntry();
  virtual ~OrderedListEntry();

  OrderedListEntry(const OrderedListEntry& from);

  inline OrderedListEntry& operator=(const OrderedListEntry& from) {
    CopyFrom(from);
    return *this;
  }

  static const OrderedListEntry& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const OrderedListEntry* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(OrderedListEntry* other);

  // implements Message ----------------------------------------------

  OrderedListEntry* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const OrderedListEntry& from);
  void MergeFrom(const OrderedListEntry& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // required .Impinj.STP.EPCMemory EPC_memory = 1;
  inline bool has_epc_memory() const;
  inline void clear_epc_memory();
  static const int kEPCMemoryFieldNumber = 1;
  inline const ::Impinj::STP::EPCMemory& epc_memory() const;
  inline ::Impinj::STP::EPCMemory* mutable_epc_memory();
  inline ::Impinj::STP::EPCMemory* release_epc_memory();
  inline void set_allocated_epc_memory(::Impinj::STP::EPCMemory* epc_memory);

  // optional .Impinj.STP.UserMemory user_memory = 2;
  inline bool has_user_memory() const;
  inline void clear_user_memory();
  static const int kUserMemoryFieldNumber = 2;
  inline const ::Impinj::STP::UserMemory& user_memory() const;
  inline ::Impinj::STP::UserMemory* mutable_user_memory();
  inline ::Impinj::STP::UserMemory* release_user_memory();
  inline void set_allocated_user_memory(::Impinj::STP::UserMemory* user_memory);

  // optional .Impinj.STP.Password secure_password = 3;
  inline bool has_secure_password() const;
  inline void clear_secure_password();
  static const int kSecurePasswordFieldNumber = 3;
  inline const ::Impinj::STP::Password& secure_password() const;
  inline ::Impinj::STP::Password* mutable_secure_password();
  inline ::Impinj::STP::Password* release_secure_password();
  inline void set_allocated_secure_password(::Impinj::STP::Password* secure_password);

  // optional .Impinj.STP.Password access_password = 4;
  inline bool has_access_password() const;
  inline void clear_access_password();
  static const int kAccessPasswordFieldNumber = 4;
  inline const ::Impinj::STP::Password& access_password() const;
  inline ::Impinj::STP::Password* mutable_access_password();
  inline ::Impinj::STP::Password* release_access_password();
  inline void set_allocated_access_password(::Impinj::STP::Password* access_password);

  // optional .Impinj.STP.Password kill_password = 5;
  inline bool has_kill_password() const;
  inline void clear_kill_password();
  static const int kKillPasswordFieldNumber = 5;
  inline const ::Impinj::STP::Password& kill_password() const;
  inline ::Impinj::STP::Password* mutable_kill_password();
  inline ::Impinj::STP::Password* release_kill_password();
  inline void set_allocated_kill_password(::Impinj::STP::Password* kill_password);

  // optional .Impinj.STP.LockConfig lock_config = 6;
  inline bool has_lock_config() const;
  inline void clear_lock_config();
  static const int kLockConfigFieldNumber = 6;
  inline const ::Impinj::STP::LockConfig& lock_config() const;
  inline ::Impinj::STP::LockConfig* mutable_lock_config();
  inline ::Impinj::STP::LockConfig* release_lock_config();
  inline void set_allocated_lock_config(::Impinj::STP::LockConfig* lock_config);

  // optional .Impinj.STP.BlockPermalockConfig blockpermalock_config = 7;
  inline bool has_blockpermalock_config() const;
  inline void clear_blockpermalock_config();
  static const int kBlockpermalockConfigFieldNumber = 7;
  inline const ::Impinj::STP::BlockPermalockConfig& blockpermalock_config() const;
  inline ::Impinj::STP::BlockPermalockConfig* mutable_blockpermalock_config();
  inline ::Impinj::STP::BlockPermalockConfig* release_blockpermalock_config();
  inline void set_allocated_blockpermalock_config(::Impinj::STP::BlockPermalockConfig* blockpermalock_config);

  // optional .Impinj.STP.TIDMemory TID_memory = 8;
  inline bool has_tid_memory() const;
  inline void clear_tid_memory();
  static const int kTIDMemoryFieldNumber = 8;
  inline const ::Impinj::STP::TIDMemory& tid_memory() const;
  inline ::Impinj::STP::TIDMemory* mutable_tid_memory();
  inline ::Impinj::STP::TIDMemory* release_tid_memory();
  inline void set_allocated_tid_memory(::Impinj::STP::TIDMemory* tid_memory);

  // optional .Impinj.STP.MonzaR6PFeatureConfig monza_r6p_feature_config = 10;
  inline bool has_monza_r6p_feature_config() const;
  inline void clear_monza_r6p_feature_config();
  static const int kMonzaR6PFeatureConfigFieldNumber = 10;
  inline const ::Impinj::STP::MonzaR6PFeatureConfig& monza_r6p_feature_config() const;
  inline ::Impinj::STP::MonzaR6PFeatureConfig* mutable_monza_r6p_feature_config();
  inline ::Impinj::STP::MonzaR6PFeatureConfig* release_monza_r6p_feature_config();
  inline void set_allocated_monza_r6p_feature_config(::Impinj::STP::MonzaR6PFeatureConfig* monza_r6p_feature_config);

  // optional .Impinj.STP.MonzaS6CFeatureConfig monza_s6c_feature_config = 11;
  inline bool has_monza_s6c_feature_config() const;
  inline void clear_monza_s6c_feature_config();
  static const int kMonzaS6CFeatureConfigFieldNumber = 11;
  inline const ::Impinj::STP::MonzaS6CFeatureConfig& monza_s6c_feature_config() const;
  inline ::Impinj::STP::MonzaS6CFeatureConfig* mutable_monza_s6c_feature_config();
  inline ::Impinj::STP::MonzaS6CFeatureConfig* release_monza_s6c_feature_config();
  inline void set_allocated_monza_s6c_feature_config(::Impinj::STP::MonzaS6CFeatureConfig* monza_s6c_feature_config);

  // optional .Impinj.STP.MonzaR6FeatureConfig monza_r6_feature_config = 12;
  inline bool has_monza_r6_feature_config() const;
  inline void clear_monza_r6_feature_config();
  static const int kMonzaR6FeatureConfigFieldNumber = 12;
  inline const ::Impinj::STP::MonzaR6FeatureConfig& monza_r6_feature_config() const;
  inline ::Impinj::STP::MonzaR6FeatureConfig* mutable_monza_r6_feature_config();
  inline ::Impinj::STP::MonzaR6FeatureConfig* release_monza_r6_feature_config();
  inline void set_allocated_monza_r6_feature_config(::Impinj::STP::MonzaR6FeatureConfig* monza_r6_feature_config);

  // optional .Impinj.STP.MonzaR6AFeatureConfig monza_r6a_feature_config = 13;
  inline bool has_monza_r6a_feature_config() const;
  inline void clear_monza_r6a_feature_config();
  static const int kMonzaR6AFeatureConfigFieldNumber = 13;
  inline const ::Impinj::STP::MonzaR6AFeatureConfig& monza_r6a_feature_config() const;
  inline ::Impinj::STP::MonzaR6AFeatureConfig* mutable_monza_r6a_feature_config();
  inline ::Impinj::STP::MonzaR6AFeatureConfig* release_monza_r6a_feature_config();
  inline void set_allocated_monza_r6a_feature_config(::Impinj::STP::MonzaR6AFeatureConfig* monza_r6a_feature_config);

  // @@protoc_insertion_point(class_scope:Impinj.STP.OrderedListEntry)
 private:
  inline void set_has_epc_memory();
  inline void clear_has_epc_memory();
  inline void set_has_user_memory();
  inline void clear_has_user_memory();
  inline void set_has_secure_password();
  inline void clear_has_secure_password();
  inline void set_has_access_password();
  inline void clear_has_access_password();
  inline void set_has_kill_password();
  inline void clear_has_kill_password();
  inline void set_has_lock_config();
  inline void clear_has_lock_config();
  inline void set_has_blockpermalock_config();
  inline void clear_has_blockpermalock_config();
  inline void set_has_tid_memory();
  inline void clear_has_tid_memory();
  inline void set_has_monza_r6p_feature_config();
  inline void clear_has_monza_r6p_feature_config();
  inline void set_has_monza_s6c_feature_config();
  inline void clear_has_monza_s6c_feature_config();
  inline void set_has_monza_r6_feature_config();
  inline void clear_has_monza_r6_feature_config();
  inline void set_has_monza_r6a_feature_config();
  inline void clear_has_monza_r6a_feature_config();

  ::Impinj::STP::EPCMemory* epc_memory_;
  ::Impinj::STP::UserMemory* user_memory_;
  ::Impinj::STP::Password* secure_password_;
  ::Impinj::STP::Password* access_password_;
  ::Impinj::STP::Password* kill_password_;
  ::Impinj::STP::LockConfig* lock_config_;
  ::Impinj::STP::BlockPermalockConfig* blockpermalock_config_;
  ::Impinj::STP::TIDMemory* tid_memory_;
  ::Impinj::STP::MonzaR6PFeatureConfig* monza_r6p_feature_config_;
  ::Impinj::STP::MonzaS6CFeatureConfig* monza_s6c_feature_config_;
  ::Impinj::STP::MonzaR6FeatureConfig* monza_r6_feature_config_;
  ::Impinj::STP::MonzaR6AFeatureConfig* monza_r6a_feature_config_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(12 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static OrderedListEntry* default_instance_;
};
// -------------------------------------------------------------------

class OrderedListEntries : public ::google::protobuf::MessageLite {
 public:
  OrderedListEntries();
  virtual ~OrderedListEntries();

  OrderedListEntries(const OrderedListEntries& from);

  inline OrderedListEntries& operator=(const OrderedListEntries& from) {
    CopyFrom(from);
    return *this;
  }

  static const OrderedListEntries& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const OrderedListEntries* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(OrderedListEntries* other);

  // implements Message ----------------------------------------------

  OrderedListEntries* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const OrderedListEntries& from);
  void MergeFrom(const OrderedListEntries& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated .Impinj.STP.OrderedListEntry ordered_list_entries = 1;
  inline int ordered_list_entries_size() const;
  inline void clear_ordered_list_entries();
  static const int kOrderedListEntriesFieldNumber = 1;
  inline const ::Impinj::STP::OrderedListEntry& ordered_list_entries(int index) const;
  inline ::Impinj::STP::OrderedListEntry* mutable_ordered_list_entries(int index);
  inline ::Impinj::STP::OrderedListEntry* add_ordered_list_entries();
  inline const ::google::protobuf::RepeatedPtrField< ::Impinj::STP::OrderedListEntry >&
      ordered_list_entries() const;
  inline ::google::protobuf::RepeatedPtrField< ::Impinj::STP::OrderedListEntry >*
      mutable_ordered_list_entries();

  // @@protoc_insertion_point(class_scope:Impinj.STP.OrderedListEntries)
 private:

  ::google::protobuf::RepeatedPtrField< ::Impinj::STP::OrderedListEntry > ordered_list_entries_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static OrderedListEntries* default_instance_;
};
// -------------------------------------------------------------------

class LowEncodeVolumeEventConfig : public ::google::protobuf::MessageLite {
 public:
  LowEncodeVolumeEventConfig();
  virtual ~LowEncodeVolumeEventConfig();

  LowEncodeVolumeEventConfig(const LowEncodeVolumeEventConfig& from);

  inline LowEncodeVolumeEventConfig& operator=(const LowEncodeVolumeEventConfig& from) {
    CopyFrom(from);
    return *this;
  }

  static const LowEncodeVolumeEventConfig& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const LowEncodeVolumeEventConfig* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(LowEncodeVolumeEventConfig* other);

  // implements Message ----------------------------------------------

  LowEncodeVolumeEventConfig* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const LowEncodeVolumeEventConfig& from);
  void MergeFrom(const LowEncodeVolumeEventConfig& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional bool enable_low_encode_volume_events = 1 [default = true];
  inline bool has_enable_low_encode_volume_events() const;
  inline void clear_enable_low_encode_volume_events();
  static const int kEnableLowEncodeVolumeEventsFieldNumber = 1;
  inline bool enable_low_encode_volume_events() const;
  inline void set_enable_low_encode_volume_events(bool value);

  // optional uint64 monza_threshold = 2 [default = 200000];
  inline bool has_monza_threshold() const;
  inline void clear_monza_threshold();
  static const int kMonzaThresholdFieldNumber = 2;
  inline ::google::protobuf::uint64 monza_threshold() const;
  inline void set_monza_threshold(::google::protobuf::uint64 value);

  // optional uint64 non_monza_threshold = 3 [default = 200000];
  inline bool has_non_monza_threshold() const;
  inline void clear_non_monza_threshold();
  static const int kNonMonzaThresholdFieldNumber = 3;
  inline ::google::protobuf::uint64 non_monza_threshold() const;
  inline void set_non_monza_threshold(::google::protobuf::uint64 value);

  // optional uint32 monza_reminder_period = 4 [default = 50000];
  inline bool has_monza_reminder_period() const;
  inline void clear_monza_reminder_period();
  static const int kMonzaReminderPeriodFieldNumber = 4;
  inline ::google::protobuf::uint32 monza_reminder_period() const;
  inline void set_monza_reminder_period(::google::protobuf::uint32 value);

  // optional uint32 non_monza_reminder_period = 5 [default = 50000];
  inline bool has_non_monza_reminder_period() const;
  inline void clear_non_monza_reminder_period();
  static const int kNonMonzaReminderPeriodFieldNumber = 5;
  inline ::google::protobuf::uint32 non_monza_reminder_period() const;
  inline void set_non_monza_reminder_period(::google::protobuf::uint32 value);

  // @@protoc_insertion_point(class_scope:Impinj.STP.LowEncodeVolumeEventConfig)
 private:
  inline void set_has_enable_low_encode_volume_events();
  inline void clear_has_enable_low_encode_volume_events();
  inline void set_has_monza_threshold();
  inline void clear_has_monza_threshold();
  inline void set_has_non_monza_threshold();
  inline void clear_has_non_monza_threshold();
  inline void set_has_monza_reminder_period();
  inline void clear_has_monza_reminder_period();
  inline void set_has_non_monza_reminder_period();
  inline void clear_has_non_monza_reminder_period();

  ::google::protobuf::uint64 monza_threshold_;
  bool enable_low_encode_volume_events_;
  ::google::protobuf::uint32 monza_reminder_period_;
  ::google::protobuf::uint64 non_monza_threshold_;
  ::google::protobuf::uint32 non_monza_reminder_period_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(5 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static LowEncodeVolumeEventConfig* default_instance_;
};
// -------------------------------------------------------------------

class DeviceEventConfig : public ::google::protobuf::MessageLite {
 public:
  DeviceEventConfig();
  virtual ~DeviceEventConfig();

  DeviceEventConfig(const DeviceEventConfig& from);

  inline DeviceEventConfig& operator=(const DeviceEventConfig& from) {
    CopyFrom(from);
    return *this;
  }

  static const DeviceEventConfig& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const DeviceEventConfig* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(DeviceEventConfig* other);

  // implements Message ----------------------------------------------

  DeviceEventConfig* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const DeviceEventConfig& from);
  void MergeFrom(const DeviceEventConfig& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional bool enable_operation_events = 1 [default = true];
  inline bool has_enable_operation_events() const;
  inline void clear_enable_operation_events();
  static const int kEnableOperationEventsFieldNumber = 1;
  inline bool enable_operation_events() const;
  inline void set_enable_operation_events(bool value);

  // optional bool enable_GPI_events = 3 [default = false];
  inline bool has_enable_gpi_events() const;
  inline void clear_enable_gpi_events();
  static const int kEnableGPIEventsFieldNumber = 3;
  inline bool enable_gpi_events() const;
  inline void set_enable_gpi_events(bool value);

  // optional .Impinj.STP.LowEncodeVolumeEventConfig low_encode_volume_event_config = 6;
  inline bool has_low_encode_volume_event_config() const;
  inline void clear_low_encode_volume_event_config();
  static const int kLowEncodeVolumeEventConfigFieldNumber = 6;
  inline const ::Impinj::STP::LowEncodeVolumeEventConfig& low_encode_volume_event_config() const;
  inline ::Impinj::STP::LowEncodeVolumeEventConfig* mutable_low_encode_volume_event_config();
  inline ::Impinj::STP::LowEncodeVolumeEventConfig* release_low_encode_volume_event_config();
  inline void set_allocated_low_encode_volume_event_config(::Impinj::STP::LowEncodeVolumeEventConfig* low_encode_volume_event_config);

  // @@protoc_insertion_point(class_scope:Impinj.STP.DeviceEventConfig)
 private:
  inline void set_has_enable_operation_events();
  inline void clear_has_enable_operation_events();
  inline void set_has_enable_gpi_events();
  inline void clear_has_enable_gpi_events();
  inline void set_has_low_encode_volume_event_config();
  inline void clear_has_low_encode_volume_event_config();

  ::Impinj::STP::LowEncodeVolumeEventConfig* low_encode_volume_event_config_;
  bool enable_operation_events_;
  bool enable_gpi_events_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static DeviceEventConfig* default_instance_;
};
// -------------------------------------------------------------------

class OperationSummaryReport : public ::google::protobuf::MessageLite {
 public:
  OperationSummaryReport();
  virtual ~OperationSummaryReport();

  OperationSummaryReport(const OperationSummaryReport& from);

  inline OperationSummaryReport& operator=(const OperationSummaryReport& from) {
    CopyFrom(from);
    return *this;
  }

  static const OperationSummaryReport& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const OperationSummaryReport* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(OperationSummaryReport* other);

  // implements Message ----------------------------------------------

  OperationSummaryReport* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const OperationSummaryReport& from);
  void MergeFrom(const OperationSummaryReport& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // required .Impinj.STP.Timestamp timestamp = 1;
  inline bool has_timestamp() const;
  inline void clear_timestamp();
  static const int kTimestampFieldNumber = 1;
  inline const ::Impinj::STP::Timestamp& timestamp() const;
  inline ::Impinj::STP::Timestamp* mutable_timestamp();
  inline ::Impinj::STP::Timestamp* release_timestamp();
  inline void set_allocated_timestamp(::Impinj::STP::Timestamp* timestamp);

  // required .Impinj.STP.OperationSummaryResult operation_result = 2;
  inline bool has_operation_result() const;
  inline void clear_operation_result();
  static const int kOperationResultFieldNumber = 2;
  inline ::Impinj::STP::OperationSummaryResult operation_result() const;
  inline void set_operation_result(::Impinj::STP::OperationSummaryResult value);

  // optional string operation_result_detail = 3;
  inline bool has_operation_result_detail() const;
  inline void clear_operation_result_detail();
  static const int kOperationResultDetailFieldNumber = 3;
  inline const ::std::string& operation_result_detail() const;
  inline void set_operation_result_detail(const ::std::string& value);
  inline void set_operation_result_detail(const char* value);
  inline void set_operation_result_detail(const char* value, size_t size);
  inline ::std::string* mutable_operation_result_detail();
  inline ::std::string* release_operation_result_detail();
  inline void set_allocated_operation_result_detail(::std::string* operation_result_detail);

  // optional uint32 operation_elapsed_time = 4;
  inline bool has_operation_elapsed_time() const;
  inline void clear_operation_elapsed_time();
  static const int kOperationElapsedTimeFieldNumber = 4;
  inline ::google::protobuf::uint32 operation_elapsed_time() const;
  inline void set_operation_elapsed_time(::google::protobuf::uint32 value);

  // optional uint32 tag_operation_total_count = 5;
  inline bool has_tag_operation_total_count() const;
  inline void clear_tag_operation_total_count();
  static const int kTagOperationTotalCountFieldNumber = 5;
  inline ::google::protobuf::uint32 tag_operation_total_count() const;
  inline void set_tag_operation_total_count(::google::protobuf::uint32 value);

  // optional uint32 tag_operation_pass_count = 6;
  inline bool has_tag_operation_pass_count() const;
  inline void clear_tag_operation_pass_count();
  static const int kTagOperationPassCountFieldNumber = 6;
  inline ::google::protobuf::uint32 tag_operation_pass_count() const;
  inline void set_tag_operation_pass_count(::google::protobuf::uint32 value);

  // optional uint32 tag_operation_fail_count = 7;
  inline bool has_tag_operation_fail_count() const;
  inline void clear_tag_operation_fail_count();
  static const int kTagOperationFailCountFieldNumber = 7;
  inline ::google::protobuf::uint32 tag_operation_fail_count() const;
  inline void set_tag_operation_fail_count(::google::protobuf::uint32 value);

  // @@protoc_insertion_point(class_scope:Impinj.STP.OperationSummaryReport)
 private:
  inline void set_has_timestamp();
  inline void clear_has_timestamp();
  inline void set_has_operation_result();
  inline void clear_has_operation_result();
  inline void set_has_operation_result_detail();
  inline void clear_has_operation_result_detail();
  inline void set_has_operation_elapsed_time();
  inline void clear_has_operation_elapsed_time();
  inline void set_has_tag_operation_total_count();
  inline void clear_has_tag_operation_total_count();
  inline void set_has_tag_operation_pass_count();
  inline void clear_has_tag_operation_pass_count();
  inline void set_has_tag_operation_fail_count();
  inline void clear_has_tag_operation_fail_count();

  ::Impinj::STP::Timestamp* timestamp_;
  ::std::string* operation_result_detail_;
  int operation_result_;
  ::google::protobuf::uint32 operation_elapsed_time_;
  ::google::protobuf::uint32 tag_operation_total_count_;
  ::google::protobuf::uint32 tag_operation_pass_count_;
  ::google::protobuf::uint32 tag_operation_fail_count_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(7 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static OperationSummaryReport* default_instance_;
};
// -------------------------------------------------------------------

class TagOperationReport : public ::google::protobuf::MessageLite {
 public:
  TagOperationReport();
  virtual ~TagOperationReport();

  TagOperationReport(const TagOperationReport& from);

  inline TagOperationReport& operator=(const TagOperationReport& from) {
    CopyFrom(from);
    return *this;
  }

  static const TagOperationReport& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const TagOperationReport* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(TagOperationReport* other);

  // implements Message ----------------------------------------------

  TagOperationReport* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const TagOperationReport& from);
  void MergeFrom(const TagOperationReport& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // required .Impinj.STP.TagOperationReportType tag_operation_report_type = 1;
  inline bool has_tag_operation_report_type() const;
  inline void clear_tag_operation_report_type();
  static const int kTagOperationReportTypeFieldNumber = 1;
  inline ::Impinj::STP::TagOperationReportType tag_operation_report_type() const;
  inline void set_tag_operation_report_type(::Impinj::STP::TagOperationReportType value);

  // optional .Impinj.STP.TagOperationResult tag_operation_result = 2;
  inline bool has_tag_operation_result() const;
  inline void clear_tag_operation_result();
  static const int kTagOperationResultFieldNumber = 2;
  inline ::Impinj::STP::TagOperationResult tag_operation_result() const;
  inline void set_tag_operation_result(::Impinj::STP::TagOperationResult value);

  // optional string tag_operation_result_detail = 3;
  inline bool has_tag_operation_result_detail() const;
  inline void clear_tag_operation_result_detail();
  static const int kTagOperationResultDetailFieldNumber = 3;
  inline const ::std::string& tag_operation_result_detail() const;
  inline void set_tag_operation_result_detail(const ::std::string& value);
  inline void set_tag_operation_result_detail(const char* value);
  inline void set_tag_operation_result_detail(const char* value, size_t size);
  inline ::std::string* mutable_tag_operation_result_detail();
  inline ::std::string* release_tag_operation_result_detail();
  inline void set_allocated_tag_operation_result_detail(::std::string* tag_operation_result_detail);

  // optional bytes TID = 4;
  inline bool has_tid() const;
  inline void clear_tid();
  static const int kTIDFieldNumber = 4;
  inline const ::std::string& tid() const;
  inline void set_tid(const ::std::string& value);
  inline void set_tid(const char* value);
  inline void set_tid(const void* value, size_t size);
  inline ::std::string* mutable_tid();
  inline ::std::string* release_tid();
  inline void set_allocated_tid(::std::string* tid);

  // optional bytes EPC = 5;
  inline bool has_epc() const;
  inline void clear_epc();
  static const int kEPCFieldNumber = 5;
  inline const ::std::string& epc() const;
  inline void set_epc(const ::std::string& value);
  inline void set_epc(const char* value);
  inline void set_epc(const void* value, size_t size);
  inline ::std::string* mutable_epc();
  inline ::std::string* release_epc();
  inline void set_allocated_epc(::std::string* epc);

  // optional bytes EPC_attempted = 6;
  inline bool has_epc_attempted() const;
  inline void clear_epc_attempted();
  static const int kEPCAttemptedFieldNumber = 6;
  inline const ::std::string& epc_attempted() const;
  inline void set_epc_attempted(const ::std::string& value);
  inline void set_epc_attempted(const char* value);
  inline void set_epc_attempted(const void* value, size_t size);
  inline ::std::string* mutable_epc_attempted();
  inline ::std::string* release_epc_attempted();
  inline void set_allocated_epc_attempted(::std::string* epc_attempted);

  // optional bytes user_memory_inv = 19;
  inline bool has_user_memory_inv() const;
  inline void clear_user_memory_inv();
  static const int kUserMemoryInvFieldNumber = 19;
  inline const ::std::string& user_memory_inv() const;
  inline void set_user_memory_inv(const ::std::string& value);
  inline void set_user_memory_inv(const char* value);
  inline void set_user_memory_inv(const void* value, size_t size);
  inline ::std::string* mutable_user_memory_inv();
  inline ::std::string* release_user_memory_inv();
  inline void set_allocated_user_memory_inv(::std::string* user_memory_inv);

  // optional bool EPC_memory_result = 7;
  inline bool has_epc_memory_result() const;
  inline void clear_epc_memory_result();
  static const int kEPCMemoryResultFieldNumber = 7;
  inline bool epc_memory_result() const;
  inline void set_epc_memory_result(bool value);

  // optional bool access_password_result = 8;
  inline bool has_access_password_result() const;
  inline void clear_access_password_result();
  static const int kAccessPasswordResultFieldNumber = 8;
  inline bool access_password_result() const;
  inline void set_access_password_result(bool value);

  // optional bool kill_password_result = 9;
  inline bool has_kill_password_result() const;
  inline void clear_kill_password_result();
  static const int kKillPasswordResultFieldNumber = 9;
  inline bool kill_password_result() const;
  inline void set_kill_password_result(bool value);

  // optional bool lock_config_result = 10;
  inline bool has_lock_config_result() const;
  inline void clear_lock_config_result();
  static const int kLockConfigResultFieldNumber = 10;
  inline bool lock_config_result() const;
  inline void set_lock_config_result(bool value);

  // optional bool user_memory_result = 11;
  inline bool has_user_memory_result() const;
  inline void clear_user_memory_result();
  static const int kUserMemoryResultFieldNumber = 11;
  inline bool user_memory_result() const;
  inline void set_user_memory_result(bool value);

  // optional bool blockpermalock_result = 12;
  inline bool has_blockpermalock_result() const;
  inline void clear_blockpermalock_result();
  static const int kBlockpermalockResultFieldNumber = 12;
  inline bool blockpermalock_result() const;
  inline void set_blockpermalock_result(bool value);

  // optional bool kill_tag_result = 18;
  inline bool has_kill_tag_result() const;
  inline void clear_kill_tag_result();
  static const int kKillTagResultFieldNumber = 18;
  inline bool kill_tag_result() const;
  inline void set_kill_tag_result(bool value);

  // optional bool pc_word_result = 20;
  inline bool has_pc_word_result() const;
  inline void clear_pc_word_result();
  static const int kPcWordResultFieldNumber = 20;
  inline bool pc_word_result() const;
  inline void set_pc_word_result(bool value);

  // optional bool tag_specific_feature_config_result = 21;
  inline bool has_tag_specific_feature_config_result() const;
  inline void clear_tag_specific_feature_config_result();
  static const int kTagSpecificFeatureConfigResultFieldNumber = 21;
  inline bool tag_specific_feature_config_result() const;
  inline void set_tag_specific_feature_config_result(bool value);

  // optional bool tid_write_result = 22;
  inline bool has_tid_write_result() const;
  inline void clear_tid_write_result();
  static const int kTidWriteResultFieldNumber = 22;
  inline bool tid_write_result() const;
  inline void set_tid_write_result(bool value);

  // optional .Impinj.STP.Timestamp timestamp = 13;
  inline bool has_timestamp() const;
  inline void clear_timestamp();
  static const int kTimestampFieldNumber = 13;
  inline const ::Impinj::STP::Timestamp& timestamp() const;
  inline ::Impinj::STP::Timestamp* mutable_timestamp();
  inline ::Impinj::STP::Timestamp* release_timestamp();
  inline void set_allocated_timestamp(::Impinj::STP::Timestamp* timestamp);

  // optional uint32 antenna_ID = 14;
  inline bool has_antenna_id() const;
  inline void clear_antenna_id();
  static const int kAntennaIDFieldNumber = 14;
  inline ::google::protobuf::uint32 antenna_id() const;
  inline void set_antenna_id(::google::protobuf::uint32 value);

  // optional uint32 frequency = 15;
  inline bool has_frequency() const;
  inline void clear_frequency();
  static const int kFrequencyFieldNumber = 15;
  inline ::google::protobuf::uint32 frequency() const;
  inline void set_frequency(::google::protobuf::uint32 value);

  // optional sint32 RSSI = 16;
  inline bool has_rssi() const;
  inline void clear_rssi();
  static const int kRSSIFieldNumber = 16;
  inline ::google::protobuf::int32 rssi() const;
  inline void set_rssi(::google::protobuf::int32 value);

  // optional uint32 job_id = 17;
  inline bool has_job_id() const;
  inline void clear_job_id();
  static const int kJobIdFieldNumber = 17;
  inline ::google::protobuf::uint32 job_id() const;
  inline void set_job_id(::google::protobuf::uint32 value);

  // @@protoc_insertion_point(class_scope:Impinj.STP.TagOperationReport)
 private:
  inline void set_has_tag_operation_report_type();
  inline void clear_has_tag_operation_report_type();
  inline void set_has_tag_operation_result();
  inline void clear_has_tag_operation_result();
  inline void set_has_tag_operation_result_detail();
  inline void clear_has_tag_operation_result_detail();
  inline void set_has_tid();
  inline void clear_has_tid();
  inline void set_has_epc();
  inline void clear_has_epc();
  inline void set_has_epc_attempted();
  inline void clear_has_epc_attempted();
  inline void set_has_user_memory_inv();
  inline void clear_has_user_memory_inv();
  inline void set_has_epc_memory_result();
  inline void clear_has_epc_memory_result();
  inline void set_has_access_password_result();
  inline void clear_has_access_password_result();
  inline void set_has_kill_password_result();
  inline void clear_has_kill_password_result();
  inline void set_has_lock_config_result();
  inline void clear_has_lock_config_result();
  inline void set_has_user_memory_result();
  inline void clear_has_user_memory_result();
  inline void set_has_blockpermalock_result();
  inline void clear_has_blockpermalock_result();
  inline void set_has_kill_tag_result();
  inline void clear_has_kill_tag_result();
  inline void set_has_pc_word_result();
  inline void clear_has_pc_word_result();
  inline void set_has_tag_specific_feature_config_result();
  inline void clear_has_tag_specific_feature_config_result();
  inline void set_has_tid_write_result();
  inline void clear_has_tid_write_result();
  inline void set_has_timestamp();
  inline void clear_has_timestamp();
  inline void set_has_antenna_id();
  inline void clear_has_antenna_id();
  inline void set_has_frequency();
  inline void clear_has_frequency();
  inline void set_has_rssi();
  inline void clear_has_rssi();
  inline void set_has_job_id();
  inline void clear_has_job_id();

  int tag_operation_report_type_;
  int tag_operation_result_;
  ::std::string* tag_operation_result_detail_;
  ::std::string* tid_;
  ::std::string* epc_;
  ::std::string* epc_attempted_;
  ::std::string* user_memory_inv_;
  bool epc_memory_result_;
  bool access_password_result_;
  bool kill_password_result_;
  bool lock_config_result_;
  bool user_memory_result_;
  bool blockpermalock_result_;
  bool kill_tag_result_;
  bool pc_word_result_;
  bool tag_specific_feature_config_result_;
  bool tid_write_result_;
  ::google::protobuf::uint32 antenna_id_;
  ::Impinj::STP::Timestamp* timestamp_;
  ::google::protobuf::uint32 frequency_;
  ::google::protobuf::int32 rssi_;
  ::google::protobuf::uint32 job_id_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(22 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static TagOperationReport* default_instance_;
};
// -------------------------------------------------------------------

class CartonContentsTag : public ::google::protobuf::MessageLite {
 public:
  CartonContentsTag();
  virtual ~CartonContentsTag();

  CartonContentsTag(const CartonContentsTag& from);

  inline CartonContentsTag& operator=(const CartonContentsTag& from) {
    CopyFrom(from);
    return *this;
  }

  static const CartonContentsTag& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const CartonContentsTag* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(CartonContentsTag* other);

  // implements Message ----------------------------------------------

  CartonContentsTag* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const CartonContentsTag& from);
  void MergeFrom(const CartonContentsTag& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional bytes tid = 1;
  inline bool has_tid() const;
  inline void clear_tid();
  static const int kTidFieldNumber = 1;
  inline const ::std::string& tid() const;
  inline void set_tid(const ::std::string& value);
  inline void set_tid(const char* value);
  inline void set_tid(const void* value, size_t size);
  inline ::std::string* mutable_tid();
  inline ::std::string* release_tid();
  inline void set_allocated_tid(::std::string* tid);

  // optional bytes epc = 2;
  inline bool has_epc() const;
  inline void clear_epc();
  static const int kEpcFieldNumber = 2;
  inline const ::std::string& epc() const;
  inline void set_epc(const ::std::string& value);
  inline void set_epc(const char* value);
  inline void set_epc(const void* value, size_t size);
  inline ::std::string* mutable_epc();
  inline ::std::string* release_epc();
  inline void set_allocated_epc(::std::string* epc);

  // optional uint32 confidence = 3;
  inline bool has_confidence() const;
  inline void clear_confidence();
  static const int kConfidenceFieldNumber = 3;
  inline ::google::protobuf::uint32 confidence() const;
  inline void set_confidence(::google::protobuf::uint32 value);

  // optional uint32 metric_1 = 4;
  inline bool has_metric_1() const;
  inline void clear_metric_1();
  static const int kMetric1FieldNumber = 4;
  inline ::google::protobuf::uint32 metric_1() const;
  inline void set_metric_1(::google::protobuf::uint32 value);

  // optional uint32 metric_2 = 5;
  inline bool has_metric_2() const;
  inline void clear_metric_2();
  static const int kMetric2FieldNumber = 5;
  inline ::google::protobuf::uint32 metric_2() const;
  inline void set_metric_2(::google::protobuf::uint32 value);

  // optional uint32 metric_3 = 6;
  inline bool has_metric_3() const;
  inline void clear_metric_3();
  static const int kMetric3FieldNumber = 6;
  inline ::google::protobuf::uint32 metric_3() const;
  inline void set_metric_3(::google::protobuf::uint32 value);

  // @@protoc_insertion_point(class_scope:Impinj.STP.CartonContentsTag)
 private:
  inline void set_has_tid();
  inline void clear_has_tid();
  inline void set_has_epc();
  inline void clear_has_epc();
  inline void set_has_confidence();
  inline void clear_has_confidence();
  inline void set_has_metric_1();
  inline void clear_has_metric_1();
  inline void set_has_metric_2();
  inline void clear_has_metric_2();
  inline void set_has_metric_3();
  inline void clear_has_metric_3();

  ::std::string* tid_;
  ::std::string* epc_;
  ::google::protobuf::uint32 confidence_;
  ::google::protobuf::uint32 metric_1_;
  ::google::protobuf::uint32 metric_2_;
  ::google::protobuf::uint32 metric_3_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(6 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static CartonContentsTag* default_instance_;
};
// -------------------------------------------------------------------

class CartonContentsReport : public ::google::protobuf::MessageLite {
 public:
  CartonContentsReport();
  virtual ~CartonContentsReport();

  CartonContentsReport(const CartonContentsReport& from);

  inline CartonContentsReport& operator=(const CartonContentsReport& from) {
    CopyFrom(from);
    return *this;
  }

  static const CartonContentsReport& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const CartonContentsReport* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(CartonContentsReport* other);

  // implements Message ----------------------------------------------

  CartonContentsReport* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const CartonContentsReport& from);
  void MergeFrom(const CartonContentsReport& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .Impinj.STP.CartonContentsResult carton_contents_result = 1;
  inline bool has_carton_contents_result() const;
  inline void clear_carton_contents_result();
  static const int kCartonContentsResultFieldNumber = 1;
  inline ::Impinj::STP::CartonContentsResult carton_contents_result() const;
  inline void set_carton_contents_result(::Impinj::STP::CartonContentsResult value);

  // optional .Impinj.STP.Timestamp enter_timestamp = 5;
  inline bool has_enter_timestamp() const;
  inline void clear_enter_timestamp();
  static const int kEnterTimestampFieldNumber = 5;
  inline const ::Impinj::STP::Timestamp& enter_timestamp() const;
  inline ::Impinj::STP::Timestamp* mutable_enter_timestamp();
  inline ::Impinj::STP::Timestamp* release_enter_timestamp();
  inline void set_allocated_enter_timestamp(::Impinj::STP::Timestamp* enter_timestamp);

  // optional .Impinj.STP.Timestamp exit_timestamp = 6;
  inline bool has_exit_timestamp() const;
  inline void clear_exit_timestamp();
  static const int kExitTimestampFieldNumber = 6;
  inline const ::Impinj::STP::Timestamp& exit_timestamp() const;
  inline ::Impinj::STP::Timestamp* mutable_exit_timestamp();
  inline ::Impinj::STP::Timestamp* release_exit_timestamp();
  inline void set_allocated_exit_timestamp(::Impinj::STP::Timestamp* exit_timestamp);

  // optional uint32 carton_size = 7;
  inline bool has_carton_size() const;
  inline void clear_carton_size();
  static const int kCartonSizeFieldNumber = 7;
  inline ::google::protobuf::uint32 carton_size() const;
  inline void set_carton_size(::google::protobuf::uint32 value);

  // repeated .Impinj.STP.CartonContentsTag carton_contents_tag = 4;
  inline int carton_contents_tag_size() const;
  inline void clear_carton_contents_tag();
  static const int kCartonContentsTagFieldNumber = 4;
  inline const ::Impinj::STP::CartonContentsTag& carton_contents_tag(int index) const;
  inline ::Impinj::STP::CartonContentsTag* mutable_carton_contents_tag(int index);
  inline ::Impinj::STP::CartonContentsTag* add_carton_contents_tag();
  inline const ::google::protobuf::RepeatedPtrField< ::Impinj::STP::CartonContentsTag >&
      carton_contents_tag() const;
  inline ::google::protobuf::RepeatedPtrField< ::Impinj::STP::CartonContentsTag >*
      mutable_carton_contents_tag();

  // repeated .Impinj.STP.CartonContentsError carton_contents_error = 8;
  inline int carton_contents_error_size() const;
  inline void clear_carton_contents_error();
  static const int kCartonContentsErrorFieldNumber = 8;
  inline const ::Impinj::STP::CartonContentsError& carton_contents_error(int index) const;
  inline ::Impinj::STP::CartonContentsError* mutable_carton_contents_error(int index);
  inline ::Impinj::STP::CartonContentsError* add_carton_contents_error();
  inline const ::google::protobuf::RepeatedPtrField< ::Impinj::STP::CartonContentsError >&
      carton_contents_error() const;
  inline ::google::protobuf::RepeatedPtrField< ::Impinj::STP::CartonContentsError >*
      mutable_carton_contents_error();

  // optional .Impinj.STP.Timestamp start_timestamp = 2;
  inline bool has_start_timestamp() const;
  inline void clear_start_timestamp();
  static const int kStartTimestampFieldNumber = 2;
  inline const ::Impinj::STP::Timestamp& start_timestamp() const;
  inline ::Impinj::STP::Timestamp* mutable_start_timestamp();
  inline ::Impinj::STP::Timestamp* release_start_timestamp();
  inline void set_allocated_start_timestamp(::Impinj::STP::Timestamp* start_timestamp);

  // optional .Impinj.STP.Timestamp stop_timestamp = 3;
  inline bool has_stop_timestamp() const;
  inline void clear_stop_timestamp();
  static const int kStopTimestampFieldNumber = 3;
  inline const ::Impinj::STP::Timestamp& stop_timestamp() const;
  inline ::Impinj::STP::Timestamp* mutable_stop_timestamp();
  inline ::Impinj::STP::Timestamp* release_stop_timestamp();
  inline void set_allocated_stop_timestamp(::Impinj::STP::Timestamp* stop_timestamp);

  // @@protoc_insertion_point(class_scope:Impinj.STP.CartonContentsReport)
 private:
  inline void set_has_carton_contents_result();
  inline void clear_has_carton_contents_result();
  inline void set_has_enter_timestamp();
  inline void clear_has_enter_timestamp();
  inline void set_has_exit_timestamp();
  inline void clear_has_exit_timestamp();
  inline void set_has_carton_size();
  inline void clear_has_carton_size();
  inline void set_has_start_timestamp();
  inline void clear_has_start_timestamp();
  inline void set_has_stop_timestamp();
  inline void clear_has_stop_timestamp();

  ::Impinj::STP::Timestamp* enter_timestamp_;
  int carton_contents_result_;
  ::google::protobuf::uint32 carton_size_;
  ::Impinj::STP::Timestamp* exit_timestamp_;
  ::google::protobuf::RepeatedPtrField< ::Impinj::STP::CartonContentsTag > carton_contents_tag_;
  ::google::protobuf::RepeatedPtrField< ::Impinj::STP::CartonContentsError > carton_contents_error_;
  ::Impinj::STP::Timestamp* start_timestamp_;
  ::Impinj::STP::Timestamp* stop_timestamp_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(8 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static CartonContentsReport* default_instance_;
};
// -------------------------------------------------------------------

class CartonContentsError : public ::google::protobuf::MessageLite {
 public:
  CartonContentsError();
  virtual ~CartonContentsError();

  CartonContentsError(const CartonContentsError& from);

  inline CartonContentsError& operator=(const CartonContentsError& from) {
    CopyFrom(from);
    return *this;
  }

  static const CartonContentsError& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const CartonContentsError* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(CartonContentsError* other);

  // implements Message ----------------------------------------------

  CartonContentsError* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const CartonContentsError& from);
  void MergeFrom(const CartonContentsError& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .Impinj.STP.CartonContentsErrorType error_type = 1;
  inline bool has_error_type() const;
  inline void clear_error_type();
  static const int kErrorTypeFieldNumber = 1;
  inline ::Impinj::STP::CartonContentsErrorType error_type() const;
  inline void set_error_type(::Impinj::STP::CartonContentsErrorType value);

  // optional .Impinj.STP.Timestamp extra_timestamp = 2;
  inline bool has_extra_timestamp() const;
  inline void clear_extra_timestamp();
  static const int kExtraTimestampFieldNumber = 2;
  inline const ::Impinj::STP::Timestamp& extra_timestamp() const;
  inline ::Impinj::STP::Timestamp* mutable_extra_timestamp();
  inline ::Impinj::STP::Timestamp* release_extra_timestamp();
  inline void set_allocated_extra_timestamp(::Impinj::STP::Timestamp* extra_timestamp);

  // optional .Impinj.STP.Timestamp min_timestamp = 3;
  inline bool has_min_timestamp() const;
  inline void clear_min_timestamp();
  static const int kMinTimestampFieldNumber = 3;
  inline const ::Impinj::STP::Timestamp& min_timestamp() const;
  inline ::Impinj::STP::Timestamp* mutable_min_timestamp();
  inline ::Impinj::STP::Timestamp* release_min_timestamp();
  inline void set_allocated_min_timestamp(::Impinj::STP::Timestamp* min_timestamp);

  // optional .Impinj.STP.Timestamp max_timestamp = 4;
  inline bool has_max_timestamp() const;
  inline void clear_max_timestamp();
  static const int kMaxTimestampFieldNumber = 4;
  inline const ::Impinj::STP::Timestamp& max_timestamp() const;
  inline ::Impinj::STP::Timestamp* mutable_max_timestamp();
  inline ::Impinj::STP::Timestamp* release_max_timestamp();
  inline void set_allocated_max_timestamp(::Impinj::STP::Timestamp* max_timestamp);

  // @@protoc_insertion_point(class_scope:Impinj.STP.CartonContentsError)
 private:
  inline void set_has_error_type();
  inline void clear_has_error_type();
  inline void set_has_extra_timestamp();
  inline void clear_has_extra_timestamp();
  inline void set_has_min_timestamp();
  inline void clear_has_min_timestamp();
  inline void set_has_max_timestamp();
  inline void clear_has_max_timestamp();

  ::Impinj::STP::Timestamp* extra_timestamp_;
  ::Impinj::STP::Timestamp* min_timestamp_;
  ::Impinj::STP::Timestamp* max_timestamp_;
  int error_type_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static CartonContentsError* default_instance_;
};
// -------------------------------------------------------------------

class TagModeMetrics : public ::google::protobuf::MessageLite {
 public:
  TagModeMetrics();
  virtual ~TagModeMetrics();

  TagModeMetrics(const TagModeMetrics& from);

  inline TagModeMetrics& operator=(const TagModeMetrics& from) {
    CopyFrom(from);
    return *this;
  }

  static const TagModeMetrics& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const TagModeMetrics* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(TagModeMetrics* other);

  // implements Message ----------------------------------------------

  TagModeMetrics* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const TagModeMetrics& from);
  void MergeFrom(const TagModeMetrics& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional uint64 total_count = 1;
  inline bool has_total_count() const;
  inline void clear_total_count();
  static const int kTotalCountFieldNumber = 1;
  inline ::google::protobuf::uint64 total_count() const;
  inline void set_total_count(::google::protobuf::uint64 value);

  // optional uint64 pass_count = 2;
  inline bool has_pass_count() const;
  inline void clear_pass_count();
  static const int kPassCountFieldNumber = 2;
  inline ::google::protobuf::uint64 pass_count() const;
  inline void set_pass_count(::google::protobuf::uint64 value);

  // optional uint64 fail_count = 3;
  inline bool has_fail_count() const;
  inline void clear_fail_count();
  static const int kFailCountFieldNumber = 3;
  inline ::google::protobuf::uint64 fail_count() const;
  inline void set_fail_count(::google::protobuf::uint64 value);

  // optional uint64 void_count = 4;
  inline bool has_void_count() const;
  inline void clear_void_count();
  static const int kVoidCountFieldNumber = 4;
  inline ::google::protobuf::uint64 void_count() const;
  inline void set_void_count(::google::protobuf::uint64 value);

  // @@protoc_insertion_point(class_scope:Impinj.STP.TagModeMetrics)
 private:
  inline void set_has_total_count();
  inline void clear_has_total_count();
  inline void set_has_pass_count();
  inline void clear_has_pass_count();
  inline void set_has_fail_count();
  inline void clear_has_fail_count();
  inline void set_has_void_count();
  inline void clear_has_void_count();

  ::google::protobuf::uint64 total_count_;
  ::google::protobuf::uint64 pass_count_;
  ::google::protobuf::uint64 fail_count_;
  ::google::protobuf::uint64 void_count_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static TagModeMetrics* default_instance_;
};
// -------------------------------------------------------------------

class TagMetrics : public ::google::protobuf::MessageLite {
 public:
  TagMetrics();
  virtual ~TagMetrics();

  TagMetrics(const TagMetrics& from);

  inline TagMetrics& operator=(const TagMetrics& from) {
    CopyFrom(from);
    return *this;
  }

  static const TagMetrics& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const TagMetrics* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(TagMetrics* other);

  // implements Message ----------------------------------------------

  TagMetrics* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const TagMetrics& from);
  void MergeFrom(const TagMetrics& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional bytes tag_chip = 1;
  inline bool has_tag_chip() const;
  inline void clear_tag_chip();
  static const int kTagChipFieldNumber = 1;
  inline const ::std::string& tag_chip() const;
  inline void set_tag_chip(const ::std::string& value);
  inline void set_tag_chip(const char* value);
  inline void set_tag_chip(const void* value, size_t size);
  inline ::std::string* mutable_tag_chip();
  inline ::std::string* release_tag_chip();
  inline void set_allocated_tag_chip(::std::string* tag_chip);

  // optional .Impinj.STP.TagModeMetrics verify_basic_metrics = 2;
  inline bool has_verify_basic_metrics() const;
  inline void clear_verify_basic_metrics();
  static const int kVerifyBasicMetricsFieldNumber = 2;
  inline const ::Impinj::STP::TagModeMetrics& verify_basic_metrics() const;
  inline ::Impinj::STP::TagModeMetrics* mutable_verify_basic_metrics();
  inline ::Impinj::STP::TagModeMetrics* release_verify_basic_metrics();
  inline void set_allocated_verify_basic_metrics(::Impinj::STP::TagModeMetrics* verify_basic_metrics);

  // optional .Impinj.STP.TagModeMetrics verify_data_metrics = 3;
  inline bool has_verify_data_metrics() const;
  inline void clear_verify_data_metrics();
  static const int kVerifyDataMetricsFieldNumber = 3;
  inline const ::Impinj::STP::TagModeMetrics& verify_data_metrics() const;
  inline ::Impinj::STP::TagModeMetrics* mutable_verify_data_metrics();
  inline ::Impinj::STP::TagModeMetrics* release_verify_data_metrics();
  inline void set_allocated_verify_data_metrics(::Impinj::STP::TagModeMetrics* verify_data_metrics);

  // optional .Impinj.STP.TagModeMetrics encode_metrics = 4;
  inline bool has_encode_metrics() const;
  inline void clear_encode_metrics();
  static const int kEncodeMetricsFieldNumber = 4;
  inline const ::Impinj::STP::TagModeMetrics& encode_metrics() const;
  inline ::Impinj::STP::TagModeMetrics* mutable_encode_metrics();
  inline ::Impinj::STP::TagModeMetrics* release_encode_metrics();
  inline void set_allocated_encode_metrics(::Impinj::STP::TagModeMetrics* encode_metrics);

  // optional .Impinj.STP.TagModeMetrics inventory_metrics = 5;
  inline bool has_inventory_metrics() const;
  inline void clear_inventory_metrics();
  static const int kInventoryMetricsFieldNumber = 5;
  inline const ::Impinj::STP::TagModeMetrics& inventory_metrics() const;
  inline ::Impinj::STP::TagModeMetrics* mutable_inventory_metrics();
  inline ::Impinj::STP::TagModeMetrics* release_inventory_metrics();
  inline void set_allocated_inventory_metrics(::Impinj::STP::TagModeMetrics* inventory_metrics);

  // optional .Impinj.STP.TagModeMetrics carton_contents_metrics = 6;
  inline bool has_carton_contents_metrics() const;
  inline void clear_carton_contents_metrics();
  static const int kCartonContentsMetricsFieldNumber = 6;
  inline const ::Impinj::STP::TagModeMetrics& carton_contents_metrics() const;
  inline ::Impinj::STP::TagModeMetrics* mutable_carton_contents_metrics();
  inline ::Impinj::STP::TagModeMetrics* release_carton_contents_metrics();
  inline void set_allocated_carton_contents_metrics(::Impinj::STP::TagModeMetrics* carton_contents_metrics);

  // @@protoc_insertion_point(class_scope:Impinj.STP.TagMetrics)
 private:
  inline void set_has_tag_chip();
  inline void clear_has_tag_chip();
  inline void set_has_verify_basic_metrics();
  inline void clear_has_verify_basic_metrics();
  inline void set_has_verify_data_metrics();
  inline void clear_has_verify_data_metrics();
  inline void set_has_encode_metrics();
  inline void clear_has_encode_metrics();
  inline void set_has_inventory_metrics();
  inline void clear_has_inventory_metrics();
  inline void set_has_carton_contents_metrics();
  inline void clear_has_carton_contents_metrics();

  ::std::string* tag_chip_;
  ::Impinj::STP::TagModeMetrics* verify_basic_metrics_;
  ::Impinj::STP::TagModeMetrics* verify_data_metrics_;
  ::Impinj::STP::TagModeMetrics* encode_metrics_;
  ::Impinj::STP::TagModeMetrics* inventory_metrics_;
  ::Impinj::STP::TagModeMetrics* carton_contents_metrics_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(6 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static TagMetrics* default_instance_;
};
// -------------------------------------------------------------------

class InterDeviceCommunicationMetrics : public ::google::protobuf::MessageLite {
 public:
  InterDeviceCommunicationMetrics();
  virtual ~InterDeviceCommunicationMetrics();

  InterDeviceCommunicationMetrics(const InterDeviceCommunicationMetrics& from);

  inline InterDeviceCommunicationMetrics& operator=(const InterDeviceCommunicationMetrics& from) {
    CopyFrom(from);
    return *this;
  }

  static const InterDeviceCommunicationMetrics& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const InterDeviceCommunicationMetrics* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(InterDeviceCommunicationMetrics* other);

  // implements Message ----------------------------------------------

  InterDeviceCommunicationMetrics* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const InterDeviceCommunicationMetrics& from);
  void MergeFrom(const InterDeviceCommunicationMetrics& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional string serial_number = 1;
  inline bool has_serial_number() const;
  inline void clear_serial_number();
  static const int kSerialNumberFieldNumber = 1;
  inline const ::std::string& serial_number() const;
  inline void set_serial_number(const ::std::string& value);
  inline void set_serial_number(const char* value);
  inline void set_serial_number(const char* value, size_t size);
  inline ::std::string* mutable_serial_number();
  inline ::std::string* release_serial_number();
  inline void set_allocated_serial_number(::std::string* serial_number);

  // optional uint64 received_message_count = 2;
  inline bool has_received_message_count() const;
  inline void clear_received_message_count();
  static const int kReceivedMessageCountFieldNumber = 2;
  inline ::google::protobuf::uint64 received_message_count() const;
  inline void set_received_message_count(::google::protobuf::uint64 value);

  // @@protoc_insertion_point(class_scope:Impinj.STP.InterDeviceCommunicationMetrics)
 private:
  inline void set_has_serial_number();
  inline void clear_has_serial_number();
  inline void set_has_received_message_count();
  inline void clear_has_received_message_count();

  ::std::string* serial_number_;
  ::google::protobuf::uint64 received_message_count_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static InterDeviceCommunicationMetrics* default_instance_;
};
// -------------------------------------------------------------------

class OperationMetrics : public ::google::protobuf::MessageLite {
 public:
  OperationMetrics();
  virtual ~OperationMetrics();

  OperationMetrics(const OperationMetrics& from);

  inline OperationMetrics& operator=(const OperationMetrics& from) {
    CopyFrom(from);
    return *this;
  }

  static const OperationMetrics& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const OperationMetrics* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(OperationMetrics* other);

  // implements Message ----------------------------------------------

  OperationMetrics* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const OperationMetrics& from);
  void MergeFrom(const OperationMetrics& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional uint64 remaining_non_monza_encodes = 1;
  inline bool has_remaining_non_monza_encodes() const;
  inline void clear_remaining_non_monza_encodes();
  static const int kRemainingNonMonzaEncodesFieldNumber = 1;
  inline ::google::protobuf::uint64 remaining_non_monza_encodes() const;
  inline void set_remaining_non_monza_encodes(::google::protobuf::uint64 value);

  // repeated .Impinj.STP.TagMetrics tag_metrics = 2;
  inline int tag_metrics_size() const;
  inline void clear_tag_metrics();
  static const int kTagMetricsFieldNumber = 2;
  inline const ::Impinj::STP::TagMetrics& tag_metrics(int index) const;
  inline ::Impinj::STP::TagMetrics* mutable_tag_metrics(int index);
  inline ::Impinj::STP::TagMetrics* add_tag_metrics();
  inline const ::google::protobuf::RepeatedPtrField< ::Impinj::STP::TagMetrics >&
      tag_metrics() const;
  inline ::google::protobuf::RepeatedPtrField< ::Impinj::STP::TagMetrics >*
      mutable_tag_metrics();

  // repeated .Impinj.STP.InterDeviceCommunicationMetrics inter_device_communication_metrics = 3;
  inline int inter_device_communication_metrics_size() const;
  inline void clear_inter_device_communication_metrics();
  static const int kInterDeviceCommunicationMetricsFieldNumber = 3;
  inline const ::Impinj::STP::InterDeviceCommunicationMetrics& inter_device_communication_metrics(int index) const;
  inline ::Impinj::STP::InterDeviceCommunicationMetrics* mutable_inter_device_communication_metrics(int index);
  inline ::Impinj::STP::InterDeviceCommunicationMetrics* add_inter_device_communication_metrics();
  inline const ::google::protobuf::RepeatedPtrField< ::Impinj::STP::InterDeviceCommunicationMetrics >&
      inter_device_communication_metrics() const;
  inline ::google::protobuf::RepeatedPtrField< ::Impinj::STP::InterDeviceCommunicationMetrics >*
      mutable_inter_device_communication_metrics();

  // optional uint64 remaining_monza_encodes = 5;
  inline bool has_remaining_monza_encodes() const;
  inline void clear_remaining_monza_encodes();
  static const int kRemainingMonzaEncodesFieldNumber = 5;
  inline ::google::protobuf::uint64 remaining_monza_encodes() const;
  inline void set_remaining_monza_encodes(::google::protobuf::uint64 value);

  // @@protoc_insertion_point(class_scope:Impinj.STP.OperationMetrics)
 private:
  inline void set_has_remaining_non_monza_encodes();
  inline void clear_has_remaining_non_monza_encodes();
  inline void set_has_remaining_monza_encodes();
  inline void clear_has_remaining_monza_encodes();

  ::google::protobuf::uint64 remaining_non_monza_encodes_;
  ::google::protobuf::RepeatedPtrField< ::Impinj::STP::TagMetrics > tag_metrics_;
  ::google::protobuf::RepeatedPtrField< ::Impinj::STP::InterDeviceCommunicationMetrics > inter_device_communication_metrics_;
  ::google::protobuf::uint64 remaining_monza_encodes_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static OperationMetrics* default_instance_;
};
// -------------------------------------------------------------------

class OperationDataDetails : public ::google::protobuf::MessageLite {
 public:
  OperationDataDetails();
  virtual ~OperationDataDetails();

  OperationDataDetails(const OperationDataDetails& from);

  inline OperationDataDetails& operator=(const OperationDataDetails& from) {
    CopyFrom(from);
    return *this;
  }

  static const OperationDataDetails& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const OperationDataDetails* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(OperationDataDetails* other);

  // implements Message ----------------------------------------------

  OperationDataDetails* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const OperationDataDetails& from);
  void MergeFrom(const OperationDataDetails& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional string serial_number = 1;
  inline bool has_serial_number() const;
  inline void clear_serial_number();
  static const int kSerialNumberFieldNumber = 1;
  inline const ::std::string& serial_number() const;
  inline void set_serial_number(const ::std::string& value);
  inline void set_serial_number(const char* value);
  inline void set_serial_number(const char* value, size_t size);
  inline ::std::string* mutable_serial_number();
  inline ::std::string* release_serial_number();
  inline void set_allocated_serial_number(::std::string* serial_number);

  // optional string firmware_version = 2;
  inline bool has_firmware_version() const;
  inline void clear_firmware_version();
  static const int kFirmwareVersionFieldNumber = 2;
  inline const ::std::string& firmware_version() const;
  inline void set_firmware_version(const ::std::string& value);
  inline void set_firmware_version(const char* value);
  inline void set_firmware_version(const char* value, size_t size);
  inline ::std::string* mutable_firmware_version();
  inline ::std::string* release_firmware_version();
  inline void set_allocated_firmware_version(::std::string* firmware_version);

  // optional string region = 3;
  inline bool has_region() const;
  inline void clear_region();
  static const int kRegionFieldNumber = 3;
  inline const ::std::string& region() const;
  inline void set_region(const ::std::string& value);
  inline void set_region(const char* value);
  inline void set_region(const char* value, size_t size);
  inline ::std::string* mutable_region();
  inline ::std::string* release_region();
  inline void set_allocated_region(::std::string* region);

  // repeated string installed_features = 4;
  inline int installed_features_size() const;
  inline void clear_installed_features();
  static const int kInstalledFeaturesFieldNumber = 4;
  inline const ::std::string& installed_features(int index) const;
  inline ::std::string* mutable_installed_features(int index);
  inline void set_installed_features(int index, const ::std::string& value);
  inline void set_installed_features(int index, const char* value);
  inline void set_installed_features(int index, const char* value, size_t size);
  inline ::std::string* add_installed_features();
  inline void add_installed_features(const ::std::string& value);
  inline void add_installed_features(const char* value);
  inline void add_installed_features(const char* value, size_t size);
  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& installed_features() const;
  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_installed_features();

  // optional uint32 non_monza_volume_key_id = 5;
  inline bool has_non_monza_volume_key_id() const;
  inline void clear_non_monza_volume_key_id();
  static const int kNonMonzaVolumeKeyIdFieldNumber = 5;
  inline ::google::protobuf::uint32 non_monza_volume_key_id() const;
  inline void set_non_monza_volume_key_id(::google::protobuf::uint32 value);

  // optional .Impinj.STP.OperationMetrics operation_metrics = 6;
  inline bool has_operation_metrics() const;
  inline void clear_operation_metrics();
  static const int kOperationMetricsFieldNumber = 6;
  inline const ::Impinj::STP::OperationMetrics& operation_metrics() const;
  inline ::Impinj::STP::OperationMetrics* mutable_operation_metrics();
  inline ::Impinj::STP::OperationMetrics* release_operation_metrics();
  inline void set_allocated_operation_metrics(::Impinj::STP::OperationMetrics* operation_metrics);

  // optional uint32 monza_volume_key_id = 7;
  inline bool has_monza_volume_key_id() const;
  inline void clear_monza_volume_key_id();
  static const int kMonzaVolumeKeyIdFieldNumber = 7;
  inline ::google::protobuf::uint32 monza_volume_key_id() const;
  inline void set_monza_volume_key_id(::google::protobuf::uint32 value);

  // @@protoc_insertion_point(class_scope:Impinj.STP.OperationDataDetails)
 private:
  inline void set_has_serial_number();
  inline void clear_has_serial_number();
  inline void set_has_firmware_version();
  inline void clear_has_firmware_version();
  inline void set_has_region();
  inline void clear_has_region();
  inline void set_has_non_monza_volume_key_id();
  inline void clear_has_non_monza_volume_key_id();
  inline void set_has_operation_metrics();
  inline void clear_has_operation_metrics();
  inline void set_has_monza_volume_key_id();
  inline void clear_has_monza_volume_key_id();

  ::std::string* serial_number_;
  ::std::string* firmware_version_;
  ::std::string* region_;
  ::google::protobuf::RepeatedPtrField< ::std::string> installed_features_;
  ::Impinj::STP::OperationMetrics* operation_metrics_;
  ::google::protobuf::uint32 non_monza_volume_key_id_;
  ::google::protobuf::uint32 monza_volume_key_id_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(7 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static OperationDataDetails* default_instance_;
};
// -------------------------------------------------------------------

class OperationData : public ::google::protobuf::MessageLite {
 public:
  OperationData();
  virtual ~OperationData();

  OperationData(const OperationData& from);

  inline OperationData& operator=(const OperationData& from) {
    CopyFrom(from);
    return *this;
  }

  static const OperationData& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const OperationData* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(OperationData* other);

  // implements Message ----------------------------------------------

  OperationData* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const OperationData& from);
  void MergeFrom(const OperationData& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .Impinj.STP.OperationDataDetails operation_details = 1;
  inline bool has_operation_details() const;
  inline void clear_operation_details();
  static const int kOperationDetailsFieldNumber = 1;
  inline const ::Impinj::STP::OperationDataDetails& operation_details() const;
  inline ::Impinj::STP::OperationDataDetails* mutable_operation_details();
  inline ::Impinj::STP::OperationDataDetails* release_operation_details();
  inline void set_allocated_operation_details(::Impinj::STP::OperationDataDetails* operation_details);

  // repeated string data = 2;
  inline int data_size() const;
  inline void clear_data();
  static const int kDataFieldNumber = 2;
  inline const ::std::string& data(int index) const;
  inline ::std::string* mutable_data(int index);
  inline void set_data(int index, const ::std::string& value);
  inline void set_data(int index, const char* value);
  inline void set_data(int index, const char* value, size_t size);
  inline ::std::string* add_data();
  inline void add_data(const ::std::string& value);
  inline void add_data(const char* value);
  inline void add_data(const char* value, size_t size);
  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& data() const;
  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_data();

  // @@protoc_insertion_point(class_scope:Impinj.STP.OperationData)
 private:
  inline void set_has_operation_details();
  inline void clear_has_operation_details();

  ::Impinj::STP::OperationDataDetails* operation_details_;
  ::google::protobuf::RepeatedPtrField< ::std::string> data_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static OperationData* default_instance_;
};
// -------------------------------------------------------------------

class LicenseKey : public ::google::protobuf::MessageLite {
 public:
  LicenseKey();
  virtual ~LicenseKey();

  LicenseKey(const LicenseKey& from);

  inline LicenseKey& operator=(const LicenseKey& from) {
    CopyFrom(from);
    return *this;
  }

  static const LicenseKey& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const LicenseKey* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(LicenseKey* other);

  // implements Message ----------------------------------------------

  LicenseKey* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const LicenseKey& from);
  void MergeFrom(const LicenseKey& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // required bytes license_key_payload = 1;
  inline bool has_license_key_payload() const;
  inline void clear_license_key_payload();
  static const int kLicenseKeyPayloadFieldNumber = 1;
  inline const ::std::string& license_key_payload() const;
  inline void set_license_key_payload(const ::std::string& value);
  inline void set_license_key_payload(const char* value);
  inline void set_license_key_payload(const void* value, size_t size);
  inline ::std::string* mutable_license_key_payload();
  inline ::std::string* release_license_key_payload();
  inline void set_allocated_license_key_payload(::std::string* license_key_payload);

  // @@protoc_insertion_point(class_scope:Impinj.STP.LicenseKey)
 private:
  inline void set_has_license_key_payload();
  inline void clear_has_license_key_payload();

  ::std::string* license_key_payload_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static LicenseKey* default_instance_;
};
// -------------------------------------------------------------------

class OperationEvent : public ::google::protobuf::MessageLite {
 public:
  OperationEvent();
  virtual ~OperationEvent();

  OperationEvent(const OperationEvent& from);

  inline OperationEvent& operator=(const OperationEvent& from) {
    CopyFrom(from);
    return *this;
  }

  static const OperationEvent& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const OperationEvent* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(OperationEvent* other);

  // implements Message ----------------------------------------------

  OperationEvent* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const OperationEvent& from);
  void MergeFrom(const OperationEvent& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // required .Impinj.STP.Timestamp timestamp = 1;
  inline bool has_timestamp() const;
  inline void clear_timestamp();
  static const int kTimestampFieldNumber = 1;
  inline const ::Impinj::STP::Timestamp& timestamp() const;
  inline ::Impinj::STP::Timestamp* mutable_timestamp();
  inline ::Impinj::STP::Timestamp* release_timestamp();
  inline void set_allocated_timestamp(::Impinj::STP::Timestamp* timestamp);

  // required .Impinj.STP.OperationEventType operation_event_type = 2;
  inline bool has_operation_event_type() const;
  inline void clear_operation_event_type();
  static const int kOperationEventTypeFieldNumber = 2;
  inline ::Impinj::STP::OperationEventType operation_event_type() const;
  inline void set_operation_event_type(::Impinj::STP::OperationEventType value);

  // optional .Impinj.STP.OperationTriggerType operation_trigger_type = 3;
  inline bool has_operation_trigger_type() const;
  inline void clear_operation_trigger_type();
  static const int kOperationTriggerTypeFieldNumber = 3;
  inline ::Impinj::STP::OperationTriggerType operation_trigger_type() const;
  inline void set_operation_trigger_type(::Impinj::STP::OperationTriggerType value);

  // @@protoc_insertion_point(class_scope:Impinj.STP.OperationEvent)
 private:
  inline void set_has_timestamp();
  inline void clear_has_timestamp();
  inline void set_has_operation_event_type();
  inline void clear_has_operation_event_type();
  inline void set_has_operation_trigger_type();
  inline void clear_has_operation_trigger_type();

  ::Impinj::STP::Timestamp* timestamp_;
  int operation_event_type_;
  int operation_trigger_type_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static OperationEvent* default_instance_;
};
// -------------------------------------------------------------------

class DeviceExceptionEvent : public ::google::protobuf::MessageLite {
 public:
  DeviceExceptionEvent();
  virtual ~DeviceExceptionEvent();

  DeviceExceptionEvent(const DeviceExceptionEvent& from);

  inline DeviceExceptionEvent& operator=(const DeviceExceptionEvent& from) {
    CopyFrom(from);
    return *this;
  }

  static const DeviceExceptionEvent& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const DeviceExceptionEvent* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(DeviceExceptionEvent* other);

  // implements Message ----------------------------------------------

  DeviceExceptionEvent* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const DeviceExceptionEvent& from);
  void MergeFrom(const DeviceExceptionEvent& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // required .Impinj.STP.Timestamp timestamp = 1;
  inline bool has_timestamp() const;
  inline void clear_timestamp();
  static const int kTimestampFieldNumber = 1;
  inline const ::Impinj::STP::Timestamp& timestamp() const;
  inline ::Impinj::STP::Timestamp* mutable_timestamp();
  inline ::Impinj::STP::Timestamp* release_timestamp();
  inline void set_allocated_timestamp(::Impinj::STP::Timestamp* timestamp);

  // required .Impinj.STP.DeviceExceptionEventType device_exception_event_type = 2;
  inline bool has_device_exception_event_type() const;
  inline void clear_device_exception_event_type();
  static const int kDeviceExceptionEventTypeFieldNumber = 2;
  inline ::Impinj::STP::DeviceExceptionEventType device_exception_event_type() const;
  inline void set_device_exception_event_type(::Impinj::STP::DeviceExceptionEventType value);

  // required string exception_detail = 3;
  inline bool has_exception_detail() const;
  inline void clear_exception_detail();
  static const int kExceptionDetailFieldNumber = 3;
  inline const ::std::string& exception_detail() const;
  inline void set_exception_detail(const ::std::string& value);
  inline void set_exception_detail(const char* value);
  inline void set_exception_detail(const char* value, size_t size);
  inline ::std::string* mutable_exception_detail();
  inline ::std::string* release_exception_detail();
  inline void set_allocated_exception_detail(::std::string* exception_detail);

  // @@protoc_insertion_point(class_scope:Impinj.STP.DeviceExceptionEvent)
 private:
  inline void set_has_timestamp();
  inline void clear_has_timestamp();
  inline void set_has_device_exception_event_type();
  inline void clear_has_device_exception_event_type();
  inline void set_has_exception_detail();
  inline void clear_has_exception_detail();

  ::Impinj::STP::Timestamp* timestamp_;
  ::std::string* exception_detail_;
  int device_exception_event_type_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static DeviceExceptionEvent* default_instance_;
};
// -------------------------------------------------------------------

class GPIEvent : public ::google::protobuf::MessageLite {
 public:
  GPIEvent();
  virtual ~GPIEvent();

  GPIEvent(const GPIEvent& from);

  inline GPIEvent& operator=(const GPIEvent& from) {
    CopyFrom(from);
    return *this;
  }

  static const GPIEvent& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const GPIEvent* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(GPIEvent* other);

  // implements Message ----------------------------------------------

  GPIEvent* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const GPIEvent& from);
  void MergeFrom(const GPIEvent& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // required .Impinj.STP.Timestamp timestamp = 1;
  inline bool has_timestamp() const;
  inline void clear_timestamp();
  static const int kTimestampFieldNumber = 1;
  inline const ::Impinj::STP::Timestamp& timestamp() const;
  inline ::Impinj::STP::Timestamp* mutable_timestamp();
  inline ::Impinj::STP::Timestamp* release_timestamp();
  inline void set_allocated_timestamp(::Impinj::STP::Timestamp* timestamp);

  // required uint32 gpi_state = 2;
  inline bool has_gpi_state() const;
  inline void clear_gpi_state();
  static const int kGpiStateFieldNumber = 2;
  inline ::google::protobuf::uint32 gpi_state() const;
  inline void set_gpi_state(::google::protobuf::uint32 value);

  // @@protoc_insertion_point(class_scope:Impinj.STP.GPIEvent)
 private:
  inline void set_has_timestamp();
  inline void clear_has_timestamp();
  inline void set_has_gpi_state();
  inline void clear_has_gpi_state();

  ::Impinj::STP::Timestamp* timestamp_;
  ::google::protobuf::uint32 gpi_state_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static GPIEvent* default_instance_;
};
// -------------------------------------------------------------------

class LowEncodeVolumeEvent : public ::google::protobuf::MessageLite {
 public:
  LowEncodeVolumeEvent();
  virtual ~LowEncodeVolumeEvent();

  LowEncodeVolumeEvent(const LowEncodeVolumeEvent& from);

  inline LowEncodeVolumeEvent& operator=(const LowEncodeVolumeEvent& from) {
    CopyFrom(from);
    return *this;
  }

  static const LowEncodeVolumeEvent& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const LowEncodeVolumeEvent* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(LowEncodeVolumeEvent* other);

  // implements Message ----------------------------------------------

  LowEncodeVolumeEvent* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const LowEncodeVolumeEvent& from);
  void MergeFrom(const LowEncodeVolumeEvent& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .Impinj.STP.LowEncodeVolumeEventType low_encode_volume_event_type = 1;
  inline bool has_low_encode_volume_event_type() const;
  inline void clear_low_encode_volume_event_type();
  static const int kLowEncodeVolumeEventTypeFieldNumber = 1;
  inline ::Impinj::STP::LowEncodeVolumeEventType low_encode_volume_event_type() const;
  inline void set_low_encode_volume_event_type(::Impinj::STP::LowEncodeVolumeEventType value);

  // optional uint64 remaining_monza_encodes = 2;
  inline bool has_remaining_monza_encodes() const;
  inline void clear_remaining_monza_encodes();
  static const int kRemainingMonzaEncodesFieldNumber = 2;
  inline ::google::protobuf::uint64 remaining_monza_encodes() const;
  inline void set_remaining_monza_encodes(::google::protobuf::uint64 value);

  // optional uint64 remaining_non_monza_encodes = 3;
  inline bool has_remaining_non_monza_encodes() const;
  inline void clear_remaining_non_monza_encodes();
  static const int kRemainingNonMonzaEncodesFieldNumber = 3;
  inline ::google::protobuf::uint64 remaining_non_monza_encodes() const;
  inline void set_remaining_non_monza_encodes(::google::protobuf::uint64 value);

  // @@protoc_insertion_point(class_scope:Impinj.STP.LowEncodeVolumeEvent)
 private:
  inline void set_has_low_encode_volume_event_type();
  inline void clear_has_low_encode_volume_event_type();
  inline void set_has_remaining_monza_encodes();
  inline void clear_has_remaining_monza_encodes();
  inline void set_has_remaining_non_monza_encodes();
  inline void clear_has_remaining_non_monza_encodes();

  ::google::protobuf::uint64 remaining_monza_encodes_;
  ::google::protobuf::uint64 remaining_non_monza_encodes_;
  int low_encode_volume_event_type_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static LowEncodeVolumeEvent* default_instance_;
};
// -------------------------------------------------------------------

class DeviceEventReport : public ::google::protobuf::MessageLite {
 public:
  DeviceEventReport();
  virtual ~DeviceEventReport();

  DeviceEventReport(const DeviceEventReport& from);

  inline DeviceEventReport& operator=(const DeviceEventReport& from) {
    CopyFrom(from);
    return *this;
  }

  static const DeviceEventReport& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const DeviceEventReport* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(DeviceEventReport* other);

  // implements Message ----------------------------------------------

  DeviceEventReport* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const DeviceEventReport& from);
  void MergeFrom(const DeviceEventReport& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .Impinj.STP.OperationEvent operation_event = 1;
  inline bool has_operation_event() const;
  inline void clear_operation_event();
  static const int kOperationEventFieldNumber = 1;
  inline const ::Impinj::STP::OperationEvent& operation_event() const;
  inline ::Impinj::STP::OperationEvent* mutable_operation_event();
  inline ::Impinj::STP::OperationEvent* release_operation_event();
  inline void set_allocated_operation_event(::Impinj::STP::OperationEvent* operation_event);

  // optional .Impinj.STP.GPIEvent GPI_event = 3;
  inline bool has_gpi_event() const;
  inline void clear_gpi_event();
  static const int kGPIEventFieldNumber = 3;
  inline const ::Impinj::STP::GPIEvent& gpi_event() const;
  inline ::Impinj::STP::GPIEvent* mutable_gpi_event();
  inline ::Impinj::STP::GPIEvent* release_gpi_event();
  inline void set_allocated_gpi_event(::Impinj::STP::GPIEvent* gpi_event);

  // optional .Impinj.STP.DeviceExceptionEvent device_exception_event = 5;
  inline bool has_device_exception_event() const;
  inline void clear_device_exception_event();
  static const int kDeviceExceptionEventFieldNumber = 5;
  inline const ::Impinj::STP::DeviceExceptionEvent& device_exception_event() const;
  inline ::Impinj::STP::DeviceExceptionEvent* mutable_device_exception_event();
  inline ::Impinj::STP::DeviceExceptionEvent* release_device_exception_event();
  inline void set_allocated_device_exception_event(::Impinj::STP::DeviceExceptionEvent* device_exception_event);

  // optional .Impinj.STP.LowEncodeVolumeEvent low_encode_volume_event = 6;
  inline bool has_low_encode_volume_event() const;
  inline void clear_low_encode_volume_event();
  static const int kLowEncodeVolumeEventFieldNumber = 6;
  inline const ::Impinj::STP::LowEncodeVolumeEvent& low_encode_volume_event() const;
  inline ::Impinj::STP::LowEncodeVolumeEvent* mutable_low_encode_volume_event();
  inline ::Impinj::STP::LowEncodeVolumeEvent* release_low_encode_volume_event();
  inline void set_allocated_low_encode_volume_event(::Impinj::STP::LowEncodeVolumeEvent* low_encode_volume_event);

  // @@protoc_insertion_point(class_scope:Impinj.STP.DeviceEventReport)
 private:
  inline void set_has_operation_event();
  inline void clear_has_operation_event();
  inline void set_has_gpi_event();
  inline void clear_has_gpi_event();
  inline void set_has_device_exception_event();
  inline void clear_has_device_exception_event();
  inline void set_has_low_encode_volume_event();
  inline void clear_has_low_encode_volume_event();

  ::Impinj::STP::OperationEvent* operation_event_;
  ::Impinj::STP::GPIEvent* gpi_event_;
  ::Impinj::STP::DeviceExceptionEvent* device_exception_event_;
  ::Impinj::STP::LowEncodeVolumeEvent* low_encode_volume_event_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static DeviceEventReport* default_instance_;
};
// -------------------------------------------------------------------

class GetAntennaConfigCommand : public ::google::protobuf::MessageLite {
 public:
  GetAntennaConfigCommand();
  virtual ~GetAntennaConfigCommand();

  GetAntennaConfigCommand(const GetAntennaConfigCommand& from);

  inline GetAntennaConfigCommand& operator=(const GetAntennaConfigCommand& from) {
    CopyFrom(from);
    return *this;
  }

  static const GetAntennaConfigCommand& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const GetAntennaConfigCommand* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(GetAntennaConfigCommand* other);

  // implements Message ----------------------------------------------

  GetAntennaConfigCommand* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const GetAntennaConfigCommand& from);
  void MergeFrom(const GetAntennaConfigCommand& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional bool reserved = 1;
  inline bool has_reserved() const;
  inline void clear_reserved();
  static const int kReservedFieldNumber = 1;
  inline bool reserved() const;
  inline void set_reserved(bool value);

  // @@protoc_insertion_point(class_scope:Impinj.STP.GetAntennaConfigCommand)
 private:
  inline void set_has_reserved();
  inline void clear_has_reserved();

  bool reserved_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static GetAntennaConfigCommand* default_instance_;
};
// -------------------------------------------------------------------

class SetAntennaConfigCommand : public ::google::protobuf::MessageLite {
 public:
  SetAntennaConfigCommand();
  virtual ~SetAntennaConfigCommand();

  SetAntennaConfigCommand(const SetAntennaConfigCommand& from);

  inline SetAntennaConfigCommand& operator=(const SetAntennaConfigCommand& from) {
    CopyFrom(from);
    return *this;
  }

  static const SetAntennaConfigCommand& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const SetAntennaConfigCommand* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(SetAntennaConfigCommand* other);

  // implements Message ----------------------------------------------

  SetAntennaConfigCommand* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const SetAntennaConfigCommand& from);
  void MergeFrom(const SetAntennaConfigCommand& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .Impinj.STP.AntennasConfig antennas_config = 1;
  inline bool has_antennas_config() const;
  inline void clear_antennas_config();
  static const int kAntennasConfigFieldNumber = 1;
  inline const ::Impinj::STP::AntennasConfig& antennas_config() const;
  inline ::Impinj::STP::AntennasConfig* mutable_antennas_config();
  inline ::Impinj::STP::AntennasConfig* release_antennas_config();
  inline void set_allocated_antennas_config(::Impinj::STP::AntennasConfig* antennas_config);

  // @@protoc_insertion_point(class_scope:Impinj.STP.SetAntennaConfigCommand)
 private:
  inline void set_has_antennas_config();
  inline void clear_has_antennas_config();

  ::Impinj::STP::AntennasConfig* antennas_config_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static SetAntennaConfigCommand* default_instance_;
};
// -------------------------------------------------------------------

class StartCommand : public ::google::protobuf::MessageLite {
 public:
  StartCommand();
  virtual ~StartCommand();

  StartCommand(const StartCommand& from);

  inline StartCommand& operator=(const StartCommand& from) {
    CopyFrom(from);
    return *this;
  }

  static const StartCommand& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const StartCommand* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(StartCommand* other);

  // implements Message ----------------------------------------------

  StartCommand* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const StartCommand& from);
  void MergeFrom(const StartCommand& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional bool reserved = 1;
  inline bool has_reserved() const;
  inline void clear_reserved();
  static const int kReservedFieldNumber = 1;
  inline bool reserved() const;
  inline void set_reserved(bool value);

  // @@protoc_insertion_point(class_scope:Impinj.STP.StartCommand)
 private:
  inline void set_has_reserved();
  inline void clear_has_reserved();

  bool reserved_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static StartCommand* default_instance_;
};
// -------------------------------------------------------------------

class SetDeviceConfigCommand : public ::google::protobuf::MessageLite {
 public:
  SetDeviceConfigCommand();
  virtual ~SetDeviceConfigCommand();

  SetDeviceConfigCommand(const SetDeviceConfigCommand& from);

  inline SetDeviceConfigCommand& operator=(const SetDeviceConfigCommand& from) {
    CopyFrom(from);
    return *this;
  }

  static const SetDeviceConfigCommand& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const SetDeviceConfigCommand* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(SetDeviceConfigCommand* other);

  // implements Message ----------------------------------------------

  SetDeviceConfigCommand* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const SetDeviceConfigCommand& from);
  void MergeFrom(const SetDeviceConfigCommand& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // required .Impinj.STP.DeviceConfig device_config = 1;
  inline bool has_device_config() const;
  inline void clear_device_config();
  static const int kDeviceConfigFieldNumber = 1;
  inline const ::Impinj::STP::DeviceConfig& device_config() const;
  inline ::Impinj::STP::DeviceConfig* mutable_device_config();
  inline ::Impinj::STP::DeviceConfig* release_device_config();
  inline void set_allocated_device_config(::Impinj::STP::DeviceConfig* device_config);

  // @@protoc_insertion_point(class_scope:Impinj.STP.SetDeviceConfigCommand)
 private:
  inline void set_has_device_config();
  inline void clear_has_device_config();

  ::Impinj::STP::DeviceConfig* device_config_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static SetDeviceConfigCommand* default_instance_;
};
// -------------------------------------------------------------------

class GetDeviceConfigCommand : public ::google::protobuf::MessageLite {
 public:
  GetDeviceConfigCommand();
  virtual ~GetDeviceConfigCommand();

  GetDeviceConfigCommand(const GetDeviceConfigCommand& from);

  inline GetDeviceConfigCommand& operator=(const GetDeviceConfigCommand& from) {
    CopyFrom(from);
    return *this;
  }

  static const GetDeviceConfigCommand& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const GetDeviceConfigCommand* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(GetDeviceConfigCommand* other);

  // implements Message ----------------------------------------------

  GetDeviceConfigCommand* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const GetDeviceConfigCommand& from);
  void MergeFrom(const GetDeviceConfigCommand& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional bool reserved = 1;
  inline bool has_reserved() const;
  inline void clear_reserved();
  static const int kReservedFieldNumber = 1;
  inline bool reserved() const;
  inline void set_reserved(bool value);

  // @@protoc_insertion_point(class_scope:Impinj.STP.GetDeviceConfigCommand)
 private:
  inline void set_has_reserved();
  inline void clear_has_reserved();

  bool reserved_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static GetDeviceConfigCommand* default_instance_;
};
// -------------------------------------------------------------------

class EngageCommand : public ::google::protobuf::MessageLite {
 public:
  EngageCommand();
  virtual ~EngageCommand();

  EngageCommand(const EngageCommand& from);

  inline EngageCommand& operator=(const EngageCommand& from) {
    CopyFrom(from);
    return *this;
  }

  static const EngageCommand& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const EngageCommand* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(EngageCommand* other);

  // implements Message ----------------------------------------------

  EngageCommand* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const EngageCommand& from);
  void MergeFrom(const EngageCommand& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional bool reserved = 1;
  inline bool has_reserved() const;
  inline void clear_reserved();
  static const int kReservedFieldNumber = 1;
  inline bool reserved() const;
  inline void set_reserved(bool value);

  // @@protoc_insertion_point(class_scope:Impinj.STP.EngageCommand)
 private:
  inline void set_has_reserved();
  inline void clear_has_reserved();

  bool reserved_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static EngageCommand* default_instance_;
};
// -------------------------------------------------------------------

class DisengageCommand : public ::google::protobuf::MessageLite {
 public:
  DisengageCommand();
  virtual ~DisengageCommand();

  DisengageCommand(const DisengageCommand& from);

  inline DisengageCommand& operator=(const DisengageCommand& from) {
    CopyFrom(from);
    return *this;
  }

  static const DisengageCommand& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const DisengageCommand* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(DisengageCommand* other);

  // implements Message ----------------------------------------------

  DisengageCommand* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const DisengageCommand& from);
  void MergeFrom(const DisengageCommand& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional bool reserved = 1;
  inline bool has_reserved() const;
  inline void clear_reserved();
  static const int kReservedFieldNumber = 1;
  inline bool reserved() const;
  inline void set_reserved(bool value);

  // @@protoc_insertion_point(class_scope:Impinj.STP.DisengageCommand)
 private:
  inline void set_has_reserved();
  inline void clear_has_reserved();

  bool reserved_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static DisengageCommand* default_instance_;
};
// -------------------------------------------------------------------

class SetOperationResultGPOCommand : public ::google::protobuf::MessageLite {
 public:
  SetOperationResultGPOCommand();
  virtual ~SetOperationResultGPOCommand();

  SetOperationResultGPOCommand(const SetOperationResultGPOCommand& from);

  inline SetOperationResultGPOCommand& operator=(const SetOperationResultGPOCommand& from) {
    CopyFrom(from);
    return *this;
  }

  static const SetOperationResultGPOCommand& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const SetOperationResultGPOCommand* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(SetOperationResultGPOCommand* other);

  // implements Message ----------------------------------------------

  SetOperationResultGPOCommand* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const SetOperationResultGPOCommand& from);
  void MergeFrom(const SetOperationResultGPOCommand& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .Impinj.STP.OperationSummaryResult operation_summary_result = 1;
  inline bool has_operation_summary_result() const;
  inline void clear_operation_summary_result();
  static const int kOperationSummaryResultFieldNumber = 1;
  inline ::Impinj::STP::OperationSummaryResult operation_summary_result() const;
  inline void set_operation_summary_result(::Impinj::STP::OperationSummaryResult value);

  // @@protoc_insertion_point(class_scope:Impinj.STP.SetOperationResultGPOCommand)
 private:
  inline void set_has_operation_summary_result();
  inline void clear_has_operation_summary_result();

  int operation_summary_result_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static SetOperationResultGPOCommand* default_instance_;
};
// -------------------------------------------------------------------

class AddSerializationJobCommand : public ::google::protobuf::MessageLite {
 public:
  AddSerializationJobCommand();
  virtual ~AddSerializationJobCommand();

  AddSerializationJobCommand(const AddSerializationJobCommand& from);

  inline AddSerializationJobCommand& operator=(const AddSerializationJobCommand& from) {
    CopyFrom(from);
    return *this;
  }

  static const AddSerializationJobCommand& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const AddSerializationJobCommand* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(AddSerializationJobCommand* other);

  // implements Message ----------------------------------------------

  AddSerializationJobCommand* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const AddSerializationJobCommand& from);
  void MergeFrom(const AddSerializationJobCommand& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .Impinj.STP.SerializationJob serialization_job = 1;
  inline bool has_serialization_job() const;
  inline void clear_serialization_job();
  static const int kSerializationJobFieldNumber = 1;
  inline const ::Impinj::STP::SerializationJob& serialization_job() const;
  inline ::Impinj::STP::SerializationJob* mutable_serialization_job();
  inline ::Impinj::STP::SerializationJob* release_serialization_job();
  inline void set_allocated_serialization_job(::Impinj::STP::SerializationJob* serialization_job);

  // @@protoc_insertion_point(class_scope:Impinj.STP.AddSerializationJobCommand)
 private:
  inline void set_has_serialization_job();
  inline void clear_has_serialization_job();

  ::Impinj::STP::SerializationJob* serialization_job_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static AddSerializationJobCommand* default_instance_;
};
// -------------------------------------------------------------------

class RemoveSerializationJobCommand : public ::google::protobuf::MessageLite {
 public:
  RemoveSerializationJobCommand();
  virtual ~RemoveSerializationJobCommand();

  RemoveSerializationJobCommand(const RemoveSerializationJobCommand& from);

  inline RemoveSerializationJobCommand& operator=(const RemoveSerializationJobCommand& from) {
    CopyFrom(from);
    return *this;
  }

  static const RemoveSerializationJobCommand& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const RemoveSerializationJobCommand* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(RemoveSerializationJobCommand* other);

  // implements Message ----------------------------------------------

  RemoveSerializationJobCommand* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const RemoveSerializationJobCommand& from);
  void MergeFrom(const RemoveSerializationJobCommand& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional uint32 job_id = 1;
  inline bool has_job_id() const;
  inline void clear_job_id();
  static const int kJobIdFieldNumber = 1;
  inline ::google::protobuf::uint32 job_id() const;
  inline void set_job_id(::google::protobuf::uint32 value);

  // @@protoc_insertion_point(class_scope:Impinj.STP.RemoveSerializationJobCommand)
 private:
  inline void set_has_job_id();
  inline void clear_has_job_id();

  ::google::protobuf::uint32 job_id_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static RemoveSerializationJobCommand* default_instance_;
};
// -------------------------------------------------------------------

class SetInventoryJobCommand : public ::google::protobuf::MessageLite {
 public:
  SetInventoryJobCommand();
  virtual ~SetInventoryJobCommand();

  SetInventoryJobCommand(const SetInventoryJobCommand& from);

  inline SetInventoryJobCommand& operator=(const SetInventoryJobCommand& from) {
    CopyFrom(from);
    return *this;
  }

  static const SetInventoryJobCommand& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const SetInventoryJobCommand* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(SetInventoryJobCommand* other);

  // implements Message ----------------------------------------------

  SetInventoryJobCommand* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const SetInventoryJobCommand& from);
  void MergeFrom(const SetInventoryJobCommand& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .Impinj.STP.InventoryJob inventory_job = 1;
  inline bool has_inventory_job() const;
  inline void clear_inventory_job();
  static const int kInventoryJobFieldNumber = 1;
  inline const ::Impinj::STP::InventoryJob& inventory_job() const;
  inline ::Impinj::STP::InventoryJob* mutable_inventory_job();
  inline ::Impinj::STP::InventoryJob* release_inventory_job();
  inline void set_allocated_inventory_job(::Impinj::STP::InventoryJob* inventory_job);

  // @@protoc_insertion_point(class_scope:Impinj.STP.SetInventoryJobCommand)
 private:
  inline void set_has_inventory_job();
  inline void clear_has_inventory_job();

  ::Impinj::STP::InventoryJob* inventory_job_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static SetInventoryJobCommand* default_instance_;
};
// -------------------------------------------------------------------

class SetCartonContentsJobCommand : public ::google::protobuf::MessageLite {
 public:
  SetCartonContentsJobCommand();
  virtual ~SetCartonContentsJobCommand();

  SetCartonContentsJobCommand(const SetCartonContentsJobCommand& from);

  inline SetCartonContentsJobCommand& operator=(const SetCartonContentsJobCommand& from) {
    CopyFrom(from);
    return *this;
  }

  static const SetCartonContentsJobCommand& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const SetCartonContentsJobCommand* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(SetCartonContentsJobCommand* other);

  // implements Message ----------------------------------------------

  SetCartonContentsJobCommand* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const SetCartonContentsJobCommand& from);
  void MergeFrom(const SetCartonContentsJobCommand& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .Impinj.STP.CartonContentsJob carton_contents_job = 1;
  inline bool has_carton_contents_job() const;
  inline void clear_carton_contents_job();
  static const int kCartonContentsJobFieldNumber = 1;
  inline const ::Impinj::STP::CartonContentsJob& carton_contents_job() const;
  inline ::Impinj::STP::CartonContentsJob* mutable_carton_contents_job();
  inline ::Impinj::STP::CartonContentsJob* release_carton_contents_job();
  inline void set_allocated_carton_contents_job(::Impinj::STP::CartonContentsJob* carton_contents_job);

  // @@protoc_insertion_point(class_scope:Impinj.STP.SetCartonContentsJobCommand)
 private:
  inline void set_has_carton_contents_job();
  inline void clear_has_carton_contents_job();

  ::Impinj::STP::CartonContentsJob* carton_contents_job_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static SetCartonContentsJobCommand* default_instance_;
};
// -------------------------------------------------------------------

class GetOperationDataCommand : public ::google::protobuf::MessageLite {
 public:
  GetOperationDataCommand();
  virtual ~GetOperationDataCommand();

  GetOperationDataCommand(const GetOperationDataCommand& from);

  inline GetOperationDataCommand& operator=(const GetOperationDataCommand& from) {
    CopyFrom(from);
    return *this;
  }

  static const GetOperationDataCommand& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const GetOperationDataCommand* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(GetOperationDataCommand* other);

  // implements Message ----------------------------------------------

  GetOperationDataCommand* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const GetOperationDataCommand& from);
  void MergeFrom(const GetOperationDataCommand& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional bool reserved = 1;
  inline bool has_reserved() const;
  inline void clear_reserved();
  static const int kReservedFieldNumber = 1;
  inline bool reserved() const;
  inline void set_reserved(bool value);

  // @@protoc_insertion_point(class_scope:Impinj.STP.GetOperationDataCommand)
 private:
  inline void set_has_reserved();
  inline void clear_has_reserved();

  bool reserved_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static GetOperationDataCommand* default_instance_;
};
// -------------------------------------------------------------------

class AddLicenseKeyCommand : public ::google::protobuf::MessageLite {
 public:
  AddLicenseKeyCommand();
  virtual ~AddLicenseKeyCommand();

  AddLicenseKeyCommand(const AddLicenseKeyCommand& from);

  inline AddLicenseKeyCommand& operator=(const AddLicenseKeyCommand& from) {
    CopyFrom(from);
    return *this;
  }

  static const AddLicenseKeyCommand& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const AddLicenseKeyCommand* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(AddLicenseKeyCommand* other);

  // implements Message ----------------------------------------------

  AddLicenseKeyCommand* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const AddLicenseKeyCommand& from);
  void MergeFrom(const AddLicenseKeyCommand& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .Impinj.STP.LicenseKey license_key = 1;
  inline bool has_license_key() const;
  inline void clear_license_key();
  static const int kLicenseKeyFieldNumber = 1;
  inline const ::Impinj::STP::LicenseKey& license_key() const;
  inline ::Impinj::STP::LicenseKey* mutable_license_key();
  inline ::Impinj::STP::LicenseKey* release_license_key();
  inline void set_allocated_license_key(::Impinj::STP::LicenseKey* license_key);

  // @@protoc_insertion_point(class_scope:Impinj.STP.AddLicenseKeyCommand)
 private:
  inline void set_has_license_key();
  inline void clear_has_license_key();

  ::Impinj::STP::LicenseKey* license_key_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static AddLicenseKeyCommand* default_instance_;
};
// -------------------------------------------------------------------

class AddTIDTableEntriesCommand : public ::google::protobuf::MessageLite {
 public:
  AddTIDTableEntriesCommand();
  virtual ~AddTIDTableEntriesCommand();

  AddTIDTableEntriesCommand(const AddTIDTableEntriesCommand& from);

  inline AddTIDTableEntriesCommand& operator=(const AddTIDTableEntriesCommand& from) {
    CopyFrom(from);
    return *this;
  }

  static const AddTIDTableEntriesCommand& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const AddTIDTableEntriesCommand* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(AddTIDTableEntriesCommand* other);

  // implements Message ----------------------------------------------

  AddTIDTableEntriesCommand* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const AddTIDTableEntriesCommand& from);
  void MergeFrom(const AddTIDTableEntriesCommand& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .Impinj.STP.TIDTableEntries table_entries = 1;
  inline bool has_table_entries() const;
  inline void clear_table_entries();
  static const int kTableEntriesFieldNumber = 1;
  inline const ::Impinj::STP::TIDTableEntries& table_entries() const;
  inline ::Impinj::STP::TIDTableEntries* mutable_table_entries();
  inline ::Impinj::STP::TIDTableEntries* release_table_entries();
  inline void set_allocated_table_entries(::Impinj::STP::TIDTableEntries* table_entries);

  // @@protoc_insertion_point(class_scope:Impinj.STP.AddTIDTableEntriesCommand)
 private:
  inline void set_has_table_entries();
  inline void clear_has_table_entries();

  ::Impinj::STP::TIDTableEntries* table_entries_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static AddTIDTableEntriesCommand* default_instance_;
};
// -------------------------------------------------------------------

class AddOrderedListEntriesCommand : public ::google::protobuf::MessageLite {
 public:
  AddOrderedListEntriesCommand();
  virtual ~AddOrderedListEntriesCommand();

  AddOrderedListEntriesCommand(const AddOrderedListEntriesCommand& from);

  inline AddOrderedListEntriesCommand& operator=(const AddOrderedListEntriesCommand& from) {
    CopyFrom(from);
    return *this;
  }

  static const AddOrderedListEntriesCommand& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const AddOrderedListEntriesCommand* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(AddOrderedListEntriesCommand* other);

  // implements Message ----------------------------------------------

  AddOrderedListEntriesCommand* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const AddOrderedListEntriesCommand& from);
  void MergeFrom(const AddOrderedListEntriesCommand& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .Impinj.STP.OrderedListEntries ordered_list_entries = 1;
  inline bool has_ordered_list_entries() const;
  inline void clear_ordered_list_entries();
  static const int kOrderedListEntriesFieldNumber = 1;
  inline const ::Impinj::STP::OrderedListEntries& ordered_list_entries() const;
  inline ::Impinj::STP::OrderedListEntries* mutable_ordered_list_entries();
  inline ::Impinj::STP::OrderedListEntries* release_ordered_list_entries();
  inline void set_allocated_ordered_list_entries(::Impinj::STP::OrderedListEntries* ordered_list_entries);

  // @@protoc_insertion_point(class_scope:Impinj.STP.AddOrderedListEntriesCommand)
 private:
  inline void set_has_ordered_list_entries();
  inline void clear_has_ordered_list_entries();

  ::Impinj::STP::OrderedListEntries* ordered_list_entries_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static AddOrderedListEntriesCommand* default_instance_;
};
// -------------------------------------------------------------------

class StartResp : public ::google::protobuf::MessageLite {
 public:
  StartResp();
  virtual ~StartResp();

  StartResp(const StartResp& from);

  inline StartResp& operator=(const StartResp& from) {
    CopyFrom(from);
    return *this;
  }

  static const StartResp& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const StartResp* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(StartResp* other);

  // implements Message ----------------------------------------------

  StartResp* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const StartResp& from);
  void MergeFrom(const StartResp& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .Impinj.STP.Reply reply = 1;
  inline bool has_reply() const;
  inline void clear_reply();
  static const int kReplyFieldNumber = 1;
  inline const ::Impinj::STP::Reply& reply() const;
  inline ::Impinj::STP::Reply* mutable_reply();
  inline ::Impinj::STP::Reply* release_reply();
  inline void set_allocated_reply(::Impinj::STP::Reply* reply);

  // @@protoc_insertion_point(class_scope:Impinj.STP.StartResp)
 private:
  inline void set_has_reply();
  inline void clear_has_reply();

  ::Impinj::STP::Reply* reply_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static StartResp* default_instance_;
};
// -------------------------------------------------------------------

class SetDeviceConfigResp : public ::google::protobuf::MessageLite {
 public:
  SetDeviceConfigResp();
  virtual ~SetDeviceConfigResp();

  SetDeviceConfigResp(const SetDeviceConfigResp& from);

  inline SetDeviceConfigResp& operator=(const SetDeviceConfigResp& from) {
    CopyFrom(from);
    return *this;
  }

  static const SetDeviceConfigResp& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const SetDeviceConfigResp* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(SetDeviceConfigResp* other);

  // implements Message ----------------------------------------------

  SetDeviceConfigResp* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const SetDeviceConfigResp& from);
  void MergeFrom(const SetDeviceConfigResp& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .Impinj.STP.Reply reply = 1;
  inline bool has_reply() const;
  inline void clear_reply();
  static const int kReplyFieldNumber = 1;
  inline const ::Impinj::STP::Reply& reply() const;
  inline ::Impinj::STP::Reply* mutable_reply();
  inline ::Impinj::STP::Reply* release_reply();
  inline void set_allocated_reply(::Impinj::STP::Reply* reply);

  // @@protoc_insertion_point(class_scope:Impinj.STP.SetDeviceConfigResp)
 private:
  inline void set_has_reply();
  inline void clear_has_reply();

  ::Impinj::STP::Reply* reply_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static SetDeviceConfigResp* default_instance_;
};
// -------------------------------------------------------------------

class GetDeviceConfigResp : public ::google::protobuf::MessageLite {
 public:
  GetDeviceConfigResp();
  virtual ~GetDeviceConfigResp();

  GetDeviceConfigResp(const GetDeviceConfigResp& from);

  inline GetDeviceConfigResp& operator=(const GetDeviceConfigResp& from) {
    CopyFrom(from);
    return *this;
  }

  static const GetDeviceConfigResp& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const GetDeviceConfigResp* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(GetDeviceConfigResp* other);

  // implements Message ----------------------------------------------

  GetDeviceConfigResp* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const GetDeviceConfigResp& from);
  void MergeFrom(const GetDeviceConfigResp& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .Impinj.STP.Reply reply = 1;
  inline bool has_reply() const;
  inline void clear_reply();
  static const int kReplyFieldNumber = 1;
  inline const ::Impinj::STP::Reply& reply() const;
  inline ::Impinj::STP::Reply* mutable_reply();
  inline ::Impinj::STP::Reply* release_reply();
  inline void set_allocated_reply(::Impinj::STP::Reply* reply);

  // optional .Impinj.STP.DeviceConfig device_config = 2;
  inline bool has_device_config() const;
  inline void clear_device_config();
  static const int kDeviceConfigFieldNumber = 2;
  inline const ::Impinj::STP::DeviceConfig& device_config() const;
  inline ::Impinj::STP::DeviceConfig* mutable_device_config();
  inline ::Impinj::STP::DeviceConfig* release_device_config();
  inline void set_allocated_device_config(::Impinj::STP::DeviceConfig* device_config);

  // @@protoc_insertion_point(class_scope:Impinj.STP.GetDeviceConfigResp)
 private:
  inline void set_has_reply();
  inline void clear_has_reply();
  inline void set_has_device_config();
  inline void clear_has_device_config();

  ::Impinj::STP::Reply* reply_;
  ::Impinj::STP::DeviceConfig* device_config_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static GetDeviceConfigResp* default_instance_;
};
// -------------------------------------------------------------------

class SetAntennaConfigResp : public ::google::protobuf::MessageLite {
 public:
  SetAntennaConfigResp();
  virtual ~SetAntennaConfigResp();

  SetAntennaConfigResp(const SetAntennaConfigResp& from);

  inline SetAntennaConfigResp& operator=(const SetAntennaConfigResp& from) {
    CopyFrom(from);
    return *this;
  }

  static const SetAntennaConfigResp& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const SetAntennaConfigResp* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(SetAntennaConfigResp* other);

  // implements Message ----------------------------------------------

  SetAntennaConfigResp* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const SetAntennaConfigResp& from);
  void MergeFrom(const SetAntennaConfigResp& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .Impinj.STP.Reply reply = 1;
  inline bool has_reply() const;
  inline void clear_reply();
  static const int kReplyFieldNumber = 1;
  inline const ::Impinj::STP::Reply& reply() const;
  inline ::Impinj::STP::Reply* mutable_reply();
  inline ::Impinj::STP::Reply* release_reply();
  inline void set_allocated_reply(::Impinj::STP::Reply* reply);

  // @@protoc_insertion_point(class_scope:Impinj.STP.SetAntennaConfigResp)
 private:
  inline void set_has_reply();
  inline void clear_has_reply();

  ::Impinj::STP::Reply* reply_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static SetAntennaConfigResp* default_instance_;
};
// -------------------------------------------------------------------

class GetAntennaConfigResp : public ::google::protobuf::MessageLite {
 public:
  GetAntennaConfigResp();
  virtual ~GetAntennaConfigResp();

  GetAntennaConfigResp(const GetAntennaConfigResp& from);

  inline GetAntennaConfigResp& operator=(const GetAntennaConfigResp& from) {
    CopyFrom(from);
    return *this;
  }

  static const GetAntennaConfigResp& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const GetAntennaConfigResp* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(GetAntennaConfigResp* other);

  // implements Message ----------------------------------------------

  GetAntennaConfigResp* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const GetAntennaConfigResp& from);
  void MergeFrom(const GetAntennaConfigResp& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .Impinj.STP.Reply reply = 1;
  inline bool has_reply() const;
  inline void clear_reply();
  static const int kReplyFieldNumber = 1;
  inline const ::Impinj::STP::Reply& reply() const;
  inline ::Impinj::STP::Reply* mutable_reply();
  inline ::Impinj::STP::Reply* release_reply();
  inline void set_allocated_reply(::Impinj::STP::Reply* reply);

  // optional .Impinj.STP.AntennasConfig antennas_config = 2;
  inline bool has_antennas_config() const;
  inline void clear_antennas_config();
  static const int kAntennasConfigFieldNumber = 2;
  inline const ::Impinj::STP::AntennasConfig& antennas_config() const;
  inline ::Impinj::STP::AntennasConfig* mutable_antennas_config();
  inline ::Impinj::STP::AntennasConfig* release_antennas_config();
  inline void set_allocated_antennas_config(::Impinj::STP::AntennasConfig* antennas_config);

  // @@protoc_insertion_point(class_scope:Impinj.STP.GetAntennaConfigResp)
 private:
  inline void set_has_reply();
  inline void clear_has_reply();
  inline void set_has_antennas_config();
  inline void clear_has_antennas_config();

  ::Impinj::STP::Reply* reply_;
  ::Impinj::STP::AntennasConfig* antennas_config_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static GetAntennaConfigResp* default_instance_;
};
// -------------------------------------------------------------------

class EngageResp : public ::google::protobuf::MessageLite {
 public:
  EngageResp();
  virtual ~EngageResp();

  EngageResp(const EngageResp& from);

  inline EngageResp& operator=(const EngageResp& from) {
    CopyFrom(from);
    return *this;
  }

  static const EngageResp& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const EngageResp* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(EngageResp* other);

  // implements Message ----------------------------------------------

  EngageResp* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const EngageResp& from);
  void MergeFrom(const EngageResp& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .Impinj.STP.Reply reply = 1;
  inline bool has_reply() const;
  inline void clear_reply();
  static const int kReplyFieldNumber = 1;
  inline const ::Impinj::STP::Reply& reply() const;
  inline ::Impinj::STP::Reply* mutable_reply();
  inline ::Impinj::STP::Reply* release_reply();
  inline void set_allocated_reply(::Impinj::STP::Reply* reply);

  // @@protoc_insertion_point(class_scope:Impinj.STP.EngageResp)
 private:
  inline void set_has_reply();
  inline void clear_has_reply();

  ::Impinj::STP::Reply* reply_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static EngageResp* default_instance_;
};
// -------------------------------------------------------------------

class DisengageResp : public ::google::protobuf::MessageLite {
 public:
  DisengageResp();
  virtual ~DisengageResp();

  DisengageResp(const DisengageResp& from);

  inline DisengageResp& operator=(const DisengageResp& from) {
    CopyFrom(from);
    return *this;
  }

  static const DisengageResp& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const DisengageResp* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(DisengageResp* other);

  // implements Message ----------------------------------------------

  DisengageResp* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const DisengageResp& from);
  void MergeFrom(const DisengageResp& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .Impinj.STP.Reply reply = 1;
  inline bool has_reply() const;
  inline void clear_reply();
  static const int kReplyFieldNumber = 1;
  inline const ::Impinj::STP::Reply& reply() const;
  inline ::Impinj::STP::Reply* mutable_reply();
  inline ::Impinj::STP::Reply* release_reply();
  inline void set_allocated_reply(::Impinj::STP::Reply* reply);

  // @@protoc_insertion_point(class_scope:Impinj.STP.DisengageResp)
 private:
  inline void set_has_reply();
  inline void clear_has_reply();

  ::Impinj::STP::Reply* reply_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static DisengageResp* default_instance_;
};
// -------------------------------------------------------------------

class SetOperationResultGPOResp : public ::google::protobuf::MessageLite {
 public:
  SetOperationResultGPOResp();
  virtual ~SetOperationResultGPOResp();

  SetOperationResultGPOResp(const SetOperationResultGPOResp& from);

  inline SetOperationResultGPOResp& operator=(const SetOperationResultGPOResp& from) {
    CopyFrom(from);
    return *this;
  }

  static const SetOperationResultGPOResp& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const SetOperationResultGPOResp* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(SetOperationResultGPOResp* other);

  // implements Message ----------------------------------------------

  SetOperationResultGPOResp* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const SetOperationResultGPOResp& from);
  void MergeFrom(const SetOperationResultGPOResp& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .Impinj.STP.Reply reply = 1;
  inline bool has_reply() const;
  inline void clear_reply();
  static const int kReplyFieldNumber = 1;
  inline const ::Impinj::STP::Reply& reply() const;
  inline ::Impinj::STP::Reply* mutable_reply();
  inline ::Impinj::STP::Reply* release_reply();
  inline void set_allocated_reply(::Impinj::STP::Reply* reply);

  // @@protoc_insertion_point(class_scope:Impinj.STP.SetOperationResultGPOResp)
 private:
  inline void set_has_reply();
  inline void clear_has_reply();

  ::Impinj::STP::Reply* reply_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static SetOperationResultGPOResp* default_instance_;
};
// -------------------------------------------------------------------

class AddSerializationJobResp : public ::google::protobuf::MessageLite {
 public:
  AddSerializationJobResp();
  virtual ~AddSerializationJobResp();

  AddSerializationJobResp(const AddSerializationJobResp& from);

  inline AddSerializationJobResp& operator=(const AddSerializationJobResp& from) {
    CopyFrom(from);
    return *this;
  }

  static const AddSerializationJobResp& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const AddSerializationJobResp* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(AddSerializationJobResp* other);

  // implements Message ----------------------------------------------

  AddSerializationJobResp* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const AddSerializationJobResp& from);
  void MergeFrom(const AddSerializationJobResp& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .Impinj.STP.Reply reply = 1;
  inline bool has_reply() const;
  inline void clear_reply();
  static const int kReplyFieldNumber = 1;
  inline const ::Impinj::STP::Reply& reply() const;
  inline ::Impinj::STP::Reply* mutable_reply();
  inline ::Impinj::STP::Reply* release_reply();
  inline void set_allocated_reply(::Impinj::STP::Reply* reply);

  // @@protoc_insertion_point(class_scope:Impinj.STP.AddSerializationJobResp)
 private:
  inline void set_has_reply();
  inline void clear_has_reply();

  ::Impinj::STP::Reply* reply_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static AddSerializationJobResp* default_instance_;
};
// -------------------------------------------------------------------

class RemoveSerializationJobResp : public ::google::protobuf::MessageLite {
 public:
  RemoveSerializationJobResp();
  virtual ~RemoveSerializationJobResp();

  RemoveSerializationJobResp(const RemoveSerializationJobResp& from);

  inline RemoveSerializationJobResp& operator=(const RemoveSerializationJobResp& from) {
    CopyFrom(from);
    return *this;
  }

  static const RemoveSerializationJobResp& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const RemoveSerializationJobResp* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(RemoveSerializationJobResp* other);

  // implements Message ----------------------------------------------

  RemoveSerializationJobResp* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const RemoveSerializationJobResp& from);
  void MergeFrom(const RemoveSerializationJobResp& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .Impinj.STP.Reply reply = 1;
  inline bool has_reply() const;
  inline void clear_reply();
  static const int kReplyFieldNumber = 1;
  inline const ::Impinj::STP::Reply& reply() const;
  inline ::Impinj::STP::Reply* mutable_reply();
  inline ::Impinj::STP::Reply* release_reply();
  inline void set_allocated_reply(::Impinj::STP::Reply* reply);

  // @@protoc_insertion_point(class_scope:Impinj.STP.RemoveSerializationJobResp)
 private:
  inline void set_has_reply();
  inline void clear_has_reply();

  ::Impinj::STP::Reply* reply_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static RemoveSerializationJobResp* default_instance_;
};
// -------------------------------------------------------------------

class SetInventoryJobResp : public ::google::protobuf::MessageLite {
 public:
  SetInventoryJobResp();
  virtual ~SetInventoryJobResp();

  SetInventoryJobResp(const SetInventoryJobResp& from);

  inline SetInventoryJobResp& operator=(const SetInventoryJobResp& from) {
    CopyFrom(from);
    return *this;
  }

  static const SetInventoryJobResp& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const SetInventoryJobResp* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(SetInventoryJobResp* other);

  // implements Message ----------------------------------------------

  SetInventoryJobResp* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const SetInventoryJobResp& from);
  void MergeFrom(const SetInventoryJobResp& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .Impinj.STP.Reply reply = 1;
  inline bool has_reply() const;
  inline void clear_reply();
  static const int kReplyFieldNumber = 1;
  inline const ::Impinj::STP::Reply& reply() const;
  inline ::Impinj::STP::Reply* mutable_reply();
  inline ::Impinj::STP::Reply* release_reply();
  inline void set_allocated_reply(::Impinj::STP::Reply* reply);

  // @@protoc_insertion_point(class_scope:Impinj.STP.SetInventoryJobResp)
 private:
  inline void set_has_reply();
  inline void clear_has_reply();

  ::Impinj::STP::Reply* reply_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static SetInventoryJobResp* default_instance_;
};
// -------------------------------------------------------------------

class SetCartonContentsJobResp : public ::google::protobuf::MessageLite {
 public:
  SetCartonContentsJobResp();
  virtual ~SetCartonContentsJobResp();

  SetCartonContentsJobResp(const SetCartonContentsJobResp& from);

  inline SetCartonContentsJobResp& operator=(const SetCartonContentsJobResp& from) {
    CopyFrom(from);
    return *this;
  }

  static const SetCartonContentsJobResp& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const SetCartonContentsJobResp* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(SetCartonContentsJobResp* other);

  // implements Message ----------------------------------------------

  SetCartonContentsJobResp* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const SetCartonContentsJobResp& from);
  void MergeFrom(const SetCartonContentsJobResp& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .Impinj.STP.Reply reply = 1;
  inline bool has_reply() const;
  inline void clear_reply();
  static const int kReplyFieldNumber = 1;
  inline const ::Impinj::STP::Reply& reply() const;
  inline ::Impinj::STP::Reply* mutable_reply();
  inline ::Impinj::STP::Reply* release_reply();
  inline void set_allocated_reply(::Impinj::STP::Reply* reply);

  // @@protoc_insertion_point(class_scope:Impinj.STP.SetCartonContentsJobResp)
 private:
  inline void set_has_reply();
  inline void clear_has_reply();

  ::Impinj::STP::Reply* reply_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static SetCartonContentsJobResp* default_instance_;
};
// -------------------------------------------------------------------

class GetOperationDataResp : public ::google::protobuf::MessageLite {
 public:
  GetOperationDataResp();
  virtual ~GetOperationDataResp();

  GetOperationDataResp(const GetOperationDataResp& from);

  inline GetOperationDataResp& operator=(const GetOperationDataResp& from) {
    CopyFrom(from);
    return *this;
  }

  static const GetOperationDataResp& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const GetOperationDataResp* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(GetOperationDataResp* other);

  // implements Message ----------------------------------------------

  GetOperationDataResp* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const GetOperationDataResp& from);
  void MergeFrom(const GetOperationDataResp& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .Impinj.STP.Reply reply = 1;
  inline bool has_reply() const;
  inline void clear_reply();
  static const int kReplyFieldNumber = 1;
  inline const ::Impinj::STP::Reply& reply() const;
  inline ::Impinj::STP::Reply* mutable_reply();
  inline ::Impinj::STP::Reply* release_reply();
  inline void set_allocated_reply(::Impinj::STP::Reply* reply);

  // optional .Impinj.STP.OperationData operation_data = 2;
  inline bool has_operation_data() const;
  inline void clear_operation_data();
  static const int kOperationDataFieldNumber = 2;
  inline const ::Impinj::STP::OperationData& operation_data() const;
  inline ::Impinj::STP::OperationData* mutable_operation_data();
  inline ::Impinj::STP::OperationData* release_operation_data();
  inline void set_allocated_operation_data(::Impinj::STP::OperationData* operation_data);

  // @@protoc_insertion_point(class_scope:Impinj.STP.GetOperationDataResp)
 private:
  inline void set_has_reply();
  inline void clear_has_reply();
  inline void set_has_operation_data();
  inline void clear_has_operation_data();

  ::Impinj::STP::Reply* reply_;
  ::Impinj::STP::OperationData* operation_data_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static GetOperationDataResp* default_instance_;
};
// -------------------------------------------------------------------

class AddLicenseKeyResp : public ::google::protobuf::MessageLite {
 public:
  AddLicenseKeyResp();
  virtual ~AddLicenseKeyResp();

  AddLicenseKeyResp(const AddLicenseKeyResp& from);

  inline AddLicenseKeyResp& operator=(const AddLicenseKeyResp& from) {
    CopyFrom(from);
    return *this;
  }

  static const AddLicenseKeyResp& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const AddLicenseKeyResp* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(AddLicenseKeyResp* other);

  // implements Message ----------------------------------------------

  AddLicenseKeyResp* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const AddLicenseKeyResp& from);
  void MergeFrom(const AddLicenseKeyResp& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .Impinj.STP.Reply reply = 1;
  inline bool has_reply() const;
  inline void clear_reply();
  static const int kReplyFieldNumber = 1;
  inline const ::Impinj::STP::Reply& reply() const;
  inline ::Impinj::STP::Reply* mutable_reply();
  inline ::Impinj::STP::Reply* release_reply();
  inline void set_allocated_reply(::Impinj::STP::Reply* reply);

  // @@protoc_insertion_point(class_scope:Impinj.STP.AddLicenseKeyResp)
 private:
  inline void set_has_reply();
  inline void clear_has_reply();

  ::Impinj::STP::Reply* reply_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static AddLicenseKeyResp* default_instance_;
};
// -------------------------------------------------------------------

class AddTIDTableEntriesResp : public ::google::protobuf::MessageLite {
 public:
  AddTIDTableEntriesResp();
  virtual ~AddTIDTableEntriesResp();

  AddTIDTableEntriesResp(const AddTIDTableEntriesResp& from);

  inline AddTIDTableEntriesResp& operator=(const AddTIDTableEntriesResp& from) {
    CopyFrom(from);
    return *this;
  }

  static const AddTIDTableEntriesResp& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const AddTIDTableEntriesResp* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(AddTIDTableEntriesResp* other);

  // implements Message ----------------------------------------------

  AddTIDTableEntriesResp* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const AddTIDTableEntriesResp& from);
  void MergeFrom(const AddTIDTableEntriesResp& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .Impinj.STP.Reply reply = 1;
  inline bool has_reply() const;
  inline void clear_reply();
  static const int kReplyFieldNumber = 1;
  inline const ::Impinj::STP::Reply& reply() const;
  inline ::Impinj::STP::Reply* mutable_reply();
  inline ::Impinj::STP::Reply* release_reply();
  inline void set_allocated_reply(::Impinj::STP::Reply* reply);

  // @@protoc_insertion_point(class_scope:Impinj.STP.AddTIDTableEntriesResp)
 private:
  inline void set_has_reply();
  inline void clear_has_reply();

  ::Impinj::STP::Reply* reply_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static AddTIDTableEntriesResp* default_instance_;
};
// -------------------------------------------------------------------

class AddOrderedListEntriesResp : public ::google::protobuf::MessageLite {
 public:
  AddOrderedListEntriesResp();
  virtual ~AddOrderedListEntriesResp();

  AddOrderedListEntriesResp(const AddOrderedListEntriesResp& from);

  inline AddOrderedListEntriesResp& operator=(const AddOrderedListEntriesResp& from) {
    CopyFrom(from);
    return *this;
  }

  static const AddOrderedListEntriesResp& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const AddOrderedListEntriesResp* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(AddOrderedListEntriesResp* other);

  // implements Message ----------------------------------------------

  AddOrderedListEntriesResp* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const AddOrderedListEntriesResp& from);
  void MergeFrom(const AddOrderedListEntriesResp& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .Impinj.STP.Reply reply = 1;
  inline bool has_reply() const;
  inline void clear_reply();
  static const int kReplyFieldNumber = 1;
  inline const ::Impinj::STP::Reply& reply() const;
  inline ::Impinj::STP::Reply* mutable_reply();
  inline ::Impinj::STP::Reply* release_reply();
  inline void set_allocated_reply(::Impinj::STP::Reply* reply);

  // @@protoc_insertion_point(class_scope:Impinj.STP.AddOrderedListEntriesResp)
 private:
  inline void set_has_reply();
  inline void clear_has_reply();

  ::Impinj::STP::Reply* reply_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static AddOrderedListEntriesResp* default_instance_;
};
// -------------------------------------------------------------------

class Command : public ::google::protobuf::MessageLite {
 public:
  Command();
  virtual ~Command();

  Command(const Command& from);

  inline Command& operator=(const Command& from) {
    CopyFrom(from);
    return *this;
  }

  static const Command& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const Command* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(Command* other);

  // implements Message ----------------------------------------------

  Command* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const Command& from);
  void MergeFrom(const Command& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .Impinj.STP.ConnectCommand connect = 1;
  inline bool has_connect() const;
  inline void clear_connect();
  static const int kConnectFieldNumber = 1;
  inline const ::Impinj::STP::ConnectCommand& connect() const;
  inline ::Impinj::STP::ConnectCommand* mutable_connect();
  inline ::Impinj::STP::ConnectCommand* release_connect();
  inline void set_allocated_connect(::Impinj::STP::ConnectCommand* connect);

  // optional .Impinj.STP.GetVersionsReaderCommand get_versions_reader = 2;
  inline bool has_get_versions_reader() const;
  inline void clear_get_versions_reader();
  static const int kGetVersionsReaderFieldNumber = 2;
  inline const ::Impinj::STP::GetVersionsReaderCommand& get_versions_reader() const;
  inline ::Impinj::STP::GetVersionsReaderCommand* mutable_get_versions_reader();
  inline ::Impinj::STP::GetVersionsReaderCommand* release_get_versions_reader();
  inline void set_allocated_get_versions_reader(::Impinj::STP::GetVersionsReaderCommand* get_versions_reader);

  // optional .Impinj.STP.StartCommand start = 7;
  inline bool has_start() const;
  inline void clear_start();
  static const int kStartFieldNumber = 7;
  inline const ::Impinj::STP::StartCommand& start() const;
  inline ::Impinj::STP::StartCommand* mutable_start();
  inline ::Impinj::STP::StartCommand* release_start();
  inline void set_allocated_start(::Impinj::STP::StartCommand* start);

  // optional .Impinj.STP.StopCommand stop = 8;
  inline bool has_stop() const;
  inline void clear_stop();
  static const int kStopFieldNumber = 8;
  inline const ::Impinj::STP::StopCommand& stop() const;
  inline ::Impinj::STP::StopCommand* mutable_stop();
  inline ::Impinj::STP::StopCommand* release_stop();
  inline void set_allocated_stop(::Impinj::STP::StopCommand* stop);

  // optional .Impinj.STP.GetDeviceStateCommand get_device_state = 25;
  inline bool has_get_device_state() const;
  inline void clear_get_device_state();
  static const int kGetDeviceStateFieldNumber = 25;
  inline const ::Impinj::STP::GetDeviceStateCommand& get_device_state() const;
  inline ::Impinj::STP::GetDeviceStateCommand* mutable_get_device_state();
  inline ::Impinj::STP::GetDeviceStateCommand* release_get_device_state();
  inline void set_allocated_get_device_state(::Impinj::STP::GetDeviceStateCommand* get_device_state);

  // optional .Impinj.STP.SetDeviceConfigCommand set_device_config = 12032;
  inline bool has_set_device_config() const;
  inline void clear_set_device_config();
  static const int kSetDeviceConfigFieldNumber = 12032;
  inline const ::Impinj::STP::SetDeviceConfigCommand& set_device_config() const;
  inline ::Impinj::STP::SetDeviceConfigCommand* mutable_set_device_config();
  inline ::Impinj::STP::SetDeviceConfigCommand* release_set_device_config();
  inline void set_allocated_set_device_config(::Impinj::STP::SetDeviceConfigCommand* set_device_config);

  // optional .Impinj.STP.GetDeviceConfigCommand get_device_config = 12033;
  inline bool has_get_device_config() const;
  inline void clear_get_device_config();
  static const int kGetDeviceConfigFieldNumber = 12033;
  inline const ::Impinj::STP::GetDeviceConfigCommand& get_device_config() const;
  inline ::Impinj::STP::GetDeviceConfigCommand* mutable_get_device_config();
  inline ::Impinj::STP::GetDeviceConfigCommand* release_get_device_config();
  inline void set_allocated_get_device_config(::Impinj::STP::GetDeviceConfigCommand* get_device_config);

  // optional .Impinj.STP.SetAntennaConfigCommand set_antenna_config = 12034;
  inline bool has_set_antenna_config() const;
  inline void clear_set_antenna_config();
  static const int kSetAntennaConfigFieldNumber = 12034;
  inline const ::Impinj::STP::SetAntennaConfigCommand& set_antenna_config() const;
  inline ::Impinj::STP::SetAntennaConfigCommand* mutable_set_antenna_config();
  inline ::Impinj::STP::SetAntennaConfigCommand* release_set_antenna_config();
  inline void set_allocated_set_antenna_config(::Impinj::STP::SetAntennaConfigCommand* set_antenna_config);

  // optional .Impinj.STP.GetAntennaConfigCommand get_antenna_config = 12035;
  inline bool has_get_antenna_config() const;
  inline void clear_get_antenna_config();
  static const int kGetAntennaConfigFieldNumber = 12035;
  inline const ::Impinj::STP::GetAntennaConfigCommand& get_antenna_config() const;
  inline ::Impinj::STP::GetAntennaConfigCommand* mutable_get_antenna_config();
  inline ::Impinj::STP::GetAntennaConfigCommand* release_get_antenna_config();
  inline void set_allocated_get_antenna_config(::Impinj::STP::GetAntennaConfigCommand* get_antenna_config);

  // optional .Impinj.STP.EngageCommand engage = 12036;
  inline bool has_engage() const;
  inline void clear_engage();
  static const int kEngageFieldNumber = 12036;
  inline const ::Impinj::STP::EngageCommand& engage() const;
  inline ::Impinj::STP::EngageCommand* mutable_engage();
  inline ::Impinj::STP::EngageCommand* release_engage();
  inline void set_allocated_engage(::Impinj::STP::EngageCommand* engage);

  // optional .Impinj.STP.DisengageCommand disengage = 12037;
  inline bool has_disengage() const;
  inline void clear_disengage();
  static const int kDisengageFieldNumber = 12037;
  inline const ::Impinj::STP::DisengageCommand& disengage() const;
  inline ::Impinj::STP::DisengageCommand* mutable_disengage();
  inline ::Impinj::STP::DisengageCommand* release_disengage();
  inline void set_allocated_disengage(::Impinj::STP::DisengageCommand* disengage);

  // optional .Impinj.STP.SetOperationResultGPOCommand set_operation_result_gpo = 12038;
  inline bool has_set_operation_result_gpo() const;
  inline void clear_set_operation_result_gpo();
  static const int kSetOperationResultGpoFieldNumber = 12038;
  inline const ::Impinj::STP::SetOperationResultGPOCommand& set_operation_result_gpo() const;
  inline ::Impinj::STP::SetOperationResultGPOCommand* mutable_set_operation_result_gpo();
  inline ::Impinj::STP::SetOperationResultGPOCommand* release_set_operation_result_gpo();
  inline void set_allocated_set_operation_result_gpo(::Impinj::STP::SetOperationResultGPOCommand* set_operation_result_gpo);

  // optional .Impinj.STP.AddSerializationJobCommand add_serialization_job = 12039;
  inline bool has_add_serialization_job() const;
  inline void clear_add_serialization_job();
  static const int kAddSerializationJobFieldNumber = 12039;
  inline const ::Impinj::STP::AddSerializationJobCommand& add_serialization_job() const;
  inline ::Impinj::STP::AddSerializationJobCommand* mutable_add_serialization_job();
  inline ::Impinj::STP::AddSerializationJobCommand* release_add_serialization_job();
  inline void set_allocated_add_serialization_job(::Impinj::STP::AddSerializationJobCommand* add_serialization_job);

  // optional .Impinj.STP.RemoveSerializationJobCommand remove_serialization_job = 12040;
  inline bool has_remove_serialization_job() const;
  inline void clear_remove_serialization_job();
  static const int kRemoveSerializationJobFieldNumber = 12040;
  inline const ::Impinj::STP::RemoveSerializationJobCommand& remove_serialization_job() const;
  inline ::Impinj::STP::RemoveSerializationJobCommand* mutable_remove_serialization_job();
  inline ::Impinj::STP::RemoveSerializationJobCommand* release_remove_serialization_job();
  inline void set_allocated_remove_serialization_job(::Impinj::STP::RemoveSerializationJobCommand* remove_serialization_job);

  // optional .Impinj.STP.AddTIDTableEntriesCommand add_tid_table_entries = 12041;
  inline bool has_add_tid_table_entries() const;
  inline void clear_add_tid_table_entries();
  static const int kAddTidTableEntriesFieldNumber = 12041;
  inline const ::Impinj::STP::AddTIDTableEntriesCommand& add_tid_table_entries() const;
  inline ::Impinj::STP::AddTIDTableEntriesCommand* mutable_add_tid_table_entries();
  inline ::Impinj::STP::AddTIDTableEntriesCommand* release_add_tid_table_entries();
  inline void set_allocated_add_tid_table_entries(::Impinj::STP::AddTIDTableEntriesCommand* add_tid_table_entries);

  // optional .Impinj.STP.AddOrderedListEntriesCommand add_ordered_list_entries = 12042;
  inline bool has_add_ordered_list_entries() const;
  inline void clear_add_ordered_list_entries();
  static const int kAddOrderedListEntriesFieldNumber = 12042;
  inline const ::Impinj::STP::AddOrderedListEntriesCommand& add_ordered_list_entries() const;
  inline ::Impinj::STP::AddOrderedListEntriesCommand* mutable_add_ordered_list_entries();
  inline ::Impinj::STP::AddOrderedListEntriesCommand* release_add_ordered_list_entries();
  inline void set_allocated_add_ordered_list_entries(::Impinj::STP::AddOrderedListEntriesCommand* add_ordered_list_entries);

  // optional .Impinj.STP.SetInventoryJobCommand set_inventory_job = 12043;
  inline bool has_set_inventory_job() const;
  inline void clear_set_inventory_job();
  static const int kSetInventoryJobFieldNumber = 12043;
  inline const ::Impinj::STP::SetInventoryJobCommand& set_inventory_job() const;
  inline ::Impinj::STP::SetInventoryJobCommand* mutable_set_inventory_job();
  inline ::Impinj::STP::SetInventoryJobCommand* release_set_inventory_job();
  inline void set_allocated_set_inventory_job(::Impinj::STP::SetInventoryJobCommand* set_inventory_job);

  // optional .Impinj.STP.SetCartonContentsJobCommand set_carton_contents_job = 12044;
  inline bool has_set_carton_contents_job() const;
  inline void clear_set_carton_contents_job();
  static const int kSetCartonContentsJobFieldNumber = 12044;
  inline const ::Impinj::STP::SetCartonContentsJobCommand& set_carton_contents_job() const;
  inline ::Impinj::STP::SetCartonContentsJobCommand* mutable_set_carton_contents_job();
  inline ::Impinj::STP::SetCartonContentsJobCommand* release_set_carton_contents_job();
  inline void set_allocated_set_carton_contents_job(::Impinj::STP::SetCartonContentsJobCommand* set_carton_contents_job);

  // optional .Impinj.STP.GetOperationDataCommand get_operation_data = 12045;
  inline bool has_get_operation_data() const;
  inline void clear_get_operation_data();
  static const int kGetOperationDataFieldNumber = 12045;
  inline const ::Impinj::STP::GetOperationDataCommand& get_operation_data() const;
  inline ::Impinj::STP::GetOperationDataCommand* mutable_get_operation_data();
  inline ::Impinj::STP::GetOperationDataCommand* release_get_operation_data();
  inline void set_allocated_get_operation_data(::Impinj::STP::GetOperationDataCommand* get_operation_data);

  // optional .Impinj.STP.AddLicenseKeyCommand add_license_key = 12046;
  inline bool has_add_license_key() const;
  inline void clear_add_license_key();
  static const int kAddLicenseKeyFieldNumber = 12046;
  inline const ::Impinj::STP::AddLicenseKeyCommand& add_license_key() const;
  inline ::Impinj::STP::AddLicenseKeyCommand* mutable_add_license_key();
  inline ::Impinj::STP::AddLicenseKeyCommand* release_add_license_key();
  inline void set_allocated_add_license_key(::Impinj::STP::AddLicenseKeyCommand* add_license_key);

  // @@protoc_insertion_point(class_scope:Impinj.STP.Command)
 private:
  inline void set_has_connect();
  inline void clear_has_connect();
  inline void set_has_get_versions_reader();
  inline void clear_has_get_versions_reader();
  inline void set_has_start();
  inline void clear_has_start();
  inline void set_has_stop();
  inline void clear_has_stop();
  inline void set_has_get_device_state();
  inline void clear_has_get_device_state();
  inline void set_has_set_device_config();
  inline void clear_has_set_device_config();
  inline void set_has_get_device_config();
  inline void clear_has_get_device_config();
  inline void set_has_set_antenna_config();
  inline void clear_has_set_antenna_config();
  inline void set_has_get_antenna_config();
  inline void clear_has_get_antenna_config();
  inline void set_has_engage();
  inline void clear_has_engage();
  inline void set_has_disengage();
  inline void clear_has_disengage();
  inline void set_has_set_operation_result_gpo();
  inline void clear_has_set_operation_result_gpo();
  inline void set_has_add_serialization_job();
  inline void clear_has_add_serialization_job();
  inline void set_has_remove_serialization_job();
  inline void clear_has_remove_serialization_job();
  inline void set_has_add_tid_table_entries();
  inline void clear_has_add_tid_table_entries();
  inline void set_has_add_ordered_list_entries();
  inline void clear_has_add_ordered_list_entries();
  inline void set_has_set_inventory_job();
  inline void clear_has_set_inventory_job();
  inline void set_has_set_carton_contents_job();
  inline void clear_has_set_carton_contents_job();
  inline void set_has_get_operation_data();
  inline void clear_has_get_operation_data();
  inline void set_has_add_license_key();
  inline void clear_has_add_license_key();

  ::Impinj::STP::ConnectCommand* connect_;
  ::Impinj::STP::GetVersionsReaderCommand* get_versions_reader_;
  ::Impinj::STP::StartCommand* start_;
  ::Impinj::STP::StopCommand* stop_;
  ::Impinj::STP::GetDeviceStateCommand* get_device_state_;
  ::Impinj::STP::SetDeviceConfigCommand* set_device_config_;
  ::Impinj::STP::GetDeviceConfigCommand* get_device_config_;
  ::Impinj::STP::SetAntennaConfigCommand* set_antenna_config_;
  ::Impinj::STP::GetAntennaConfigCommand* get_antenna_config_;
  ::Impinj::STP::EngageCommand* engage_;
  ::Impinj::STP::DisengageCommand* disengage_;
  ::Impinj::STP::SetOperationResultGPOCommand* set_operation_result_gpo_;
  ::Impinj::STP::AddSerializationJobCommand* add_serialization_job_;
  ::Impinj::STP::RemoveSerializationJobCommand* remove_serialization_job_;
  ::Impinj::STP::AddTIDTableEntriesCommand* add_tid_table_entries_;
  ::Impinj::STP::AddOrderedListEntriesCommand* add_ordered_list_entries_;
  ::Impinj::STP::SetInventoryJobCommand* set_inventory_job_;
  ::Impinj::STP::SetCartonContentsJobCommand* set_carton_contents_job_;
  ::Impinj::STP::GetOperationDataCommand* get_operation_data_;
  ::Impinj::STP::AddLicenseKeyCommand* add_license_key_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(20 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static Command* default_instance_;
};
// -------------------------------------------------------------------

class Response : public ::google::protobuf::MessageLite {
 public:
  Response();
  virtual ~Response();

  Response(const Response& from);

  inline Response& operator=(const Response& from) {
    CopyFrom(from);
    return *this;
  }

  static const Response& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const Response* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(Response* other);

  // implements Message ----------------------------------------------

  Response* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const Response& from);
  void MergeFrom(const Response& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .Impinj.STP.ConnectResp connect = 1;
  inline bool has_connect() const;
  inline void clear_connect();
  static const int kConnectFieldNumber = 1;
  inline const ::Impinj::STP::ConnectResp& connect() const;
  inline ::Impinj::STP::ConnectResp* mutable_connect();
  inline ::Impinj::STP::ConnectResp* release_connect();
  inline void set_allocated_connect(::Impinj::STP::ConnectResp* connect);

  // optional .Impinj.STP.GetVersionsReaderResp get_versions_reader = 2;
  inline bool has_get_versions_reader() const;
  inline void clear_get_versions_reader();
  static const int kGetVersionsReaderFieldNumber = 2;
  inline const ::Impinj::STP::GetVersionsReaderResp& get_versions_reader() const;
  inline ::Impinj::STP::GetVersionsReaderResp* mutable_get_versions_reader();
  inline ::Impinj::STP::GetVersionsReaderResp* release_get_versions_reader();
  inline void set_allocated_get_versions_reader(::Impinj::STP::GetVersionsReaderResp* get_versions_reader);

  // optional .Impinj.STP.StartResp start = 7;
  inline bool has_start() const;
  inline void clear_start();
  static const int kStartFieldNumber = 7;
  inline const ::Impinj::STP::StartResp& start() const;
  inline ::Impinj::STP::StartResp* mutable_start();
  inline ::Impinj::STP::StartResp* release_start();
  inline void set_allocated_start(::Impinj::STP::StartResp* start);

  // optional .Impinj.STP.StopResp stop = 8;
  inline bool has_stop() const;
  inline void clear_stop();
  static const int kStopFieldNumber = 8;
  inline const ::Impinj::STP::StopResp& stop() const;
  inline ::Impinj::STP::StopResp* mutable_stop();
  inline ::Impinj::STP::StopResp* release_stop();
  inline void set_allocated_stop(::Impinj::STP::StopResp* stop);

  // optional .Impinj.STP.InvalidResp invalid = 15;
  inline bool has_invalid() const;
  inline void clear_invalid();
  static const int kInvalidFieldNumber = 15;
  inline const ::Impinj::STP::InvalidResp& invalid() const;
  inline ::Impinj::STP::InvalidResp* mutable_invalid();
  inline ::Impinj::STP::InvalidResp* release_invalid();
  inline void set_allocated_invalid(::Impinj::STP::InvalidResp* invalid);

  // optional .Impinj.STP.GetDeviceStateResp get_device_state = 25;
  inline bool has_get_device_state() const;
  inline void clear_get_device_state();
  static const int kGetDeviceStateFieldNumber = 25;
  inline const ::Impinj::STP::GetDeviceStateResp& get_device_state() const;
  inline ::Impinj::STP::GetDeviceStateResp* mutable_get_device_state();
  inline ::Impinj::STP::GetDeviceStateResp* release_get_device_state();
  inline void set_allocated_get_device_state(::Impinj::STP::GetDeviceStateResp* get_device_state);

  // optional .Impinj.STP.SetDeviceConfigResp set_device_config = 12032;
  inline bool has_set_device_config() const;
  inline void clear_set_device_config();
  static const int kSetDeviceConfigFieldNumber = 12032;
  inline const ::Impinj::STP::SetDeviceConfigResp& set_device_config() const;
  inline ::Impinj::STP::SetDeviceConfigResp* mutable_set_device_config();
  inline ::Impinj::STP::SetDeviceConfigResp* release_set_device_config();
  inline void set_allocated_set_device_config(::Impinj::STP::SetDeviceConfigResp* set_device_config);

  // optional .Impinj.STP.GetDeviceConfigResp get_device_config = 12033;
  inline bool has_get_device_config() const;
  inline void clear_get_device_config();
  static const int kGetDeviceConfigFieldNumber = 12033;
  inline const ::Impinj::STP::GetDeviceConfigResp& get_device_config() const;
  inline ::Impinj::STP::GetDeviceConfigResp* mutable_get_device_config();
  inline ::Impinj::STP::GetDeviceConfigResp* release_get_device_config();
  inline void set_allocated_get_device_config(::Impinj::STP::GetDeviceConfigResp* get_device_config);

  // optional .Impinj.STP.SetAntennaConfigResp set_antenna_config = 12034;
  inline bool has_set_antenna_config() const;
  inline void clear_set_antenna_config();
  static const int kSetAntennaConfigFieldNumber = 12034;
  inline const ::Impinj::STP::SetAntennaConfigResp& set_antenna_config() const;
  inline ::Impinj::STP::SetAntennaConfigResp* mutable_set_antenna_config();
  inline ::Impinj::STP::SetAntennaConfigResp* release_set_antenna_config();
  inline void set_allocated_set_antenna_config(::Impinj::STP::SetAntennaConfigResp* set_antenna_config);

  // optional .Impinj.STP.GetAntennaConfigResp get_antenna_config = 12035;
  inline bool has_get_antenna_config() const;
  inline void clear_get_antenna_config();
  static const int kGetAntennaConfigFieldNumber = 12035;
  inline const ::Impinj::STP::GetAntennaConfigResp& get_antenna_config() const;
  inline ::Impinj::STP::GetAntennaConfigResp* mutable_get_antenna_config();
  inline ::Impinj::STP::GetAntennaConfigResp* release_get_antenna_config();
  inline void set_allocated_get_antenna_config(::Impinj::STP::GetAntennaConfigResp* get_antenna_config);

  // optional .Impinj.STP.EngageResp engage = 12036;
  inline bool has_engage() const;
  inline void clear_engage();
  static const int kEngageFieldNumber = 12036;
  inline const ::Impinj::STP::EngageResp& engage() const;
  inline ::Impinj::STP::EngageResp* mutable_engage();
  inline ::Impinj::STP::EngageResp* release_engage();
  inline void set_allocated_engage(::Impinj::STP::EngageResp* engage);

  // optional .Impinj.STP.DisengageResp disengage = 12037;
  inline bool has_disengage() const;
  inline void clear_disengage();
  static const int kDisengageFieldNumber = 12037;
  inline const ::Impinj::STP::DisengageResp& disengage() const;
  inline ::Impinj::STP::DisengageResp* mutable_disengage();
  inline ::Impinj::STP::DisengageResp* release_disengage();
  inline void set_allocated_disengage(::Impinj::STP::DisengageResp* disengage);

  // optional .Impinj.STP.SetOperationResultGPOResp set_operation_result_gpo = 12041;
  inline bool has_set_operation_result_gpo() const;
  inline void clear_set_operation_result_gpo();
  static const int kSetOperationResultGpoFieldNumber = 12041;
  inline const ::Impinj::STP::SetOperationResultGPOResp& set_operation_result_gpo() const;
  inline ::Impinj::STP::SetOperationResultGPOResp* mutable_set_operation_result_gpo();
  inline ::Impinj::STP::SetOperationResultGPOResp* release_set_operation_result_gpo();
  inline void set_allocated_set_operation_result_gpo(::Impinj::STP::SetOperationResultGPOResp* set_operation_result_gpo);

  // optional .Impinj.STP.AddSerializationJobResp add_serialization_job = 12042;
  inline bool has_add_serialization_job() const;
  inline void clear_add_serialization_job();
  static const int kAddSerializationJobFieldNumber = 12042;
  inline const ::Impinj::STP::AddSerializationJobResp& add_serialization_job() const;
  inline ::Impinj::STP::AddSerializationJobResp* mutable_add_serialization_job();
  inline ::Impinj::STP::AddSerializationJobResp* release_add_serialization_job();
  inline void set_allocated_add_serialization_job(::Impinj::STP::AddSerializationJobResp* add_serialization_job);

  // optional .Impinj.STP.RemoveSerializationJobResp remove_serialization_job = 12043;
  inline bool has_remove_serialization_job() const;
  inline void clear_remove_serialization_job();
  static const int kRemoveSerializationJobFieldNumber = 12043;
  inline const ::Impinj::STP::RemoveSerializationJobResp& remove_serialization_job() const;
  inline ::Impinj::STP::RemoveSerializationJobResp* mutable_remove_serialization_job();
  inline ::Impinj::STP::RemoveSerializationJobResp* release_remove_serialization_job();
  inline void set_allocated_remove_serialization_job(::Impinj::STP::RemoveSerializationJobResp* remove_serialization_job);

  // optional .Impinj.STP.AddTIDTableEntriesResp add_tid_table_entries = 12044;
  inline bool has_add_tid_table_entries() const;
  inline void clear_add_tid_table_entries();
  static const int kAddTidTableEntriesFieldNumber = 12044;
  inline const ::Impinj::STP::AddTIDTableEntriesResp& add_tid_table_entries() const;
  inline ::Impinj::STP::AddTIDTableEntriesResp* mutable_add_tid_table_entries();
  inline ::Impinj::STP::AddTIDTableEntriesResp* release_add_tid_table_entries();
  inline void set_allocated_add_tid_table_entries(::Impinj::STP::AddTIDTableEntriesResp* add_tid_table_entries);

  // optional .Impinj.STP.AddOrderedListEntriesResp add_ordered_list_entries = 12045;
  inline bool has_add_ordered_list_entries() const;
  inline void clear_add_ordered_list_entries();
  static const int kAddOrderedListEntriesFieldNumber = 12045;
  inline const ::Impinj::STP::AddOrderedListEntriesResp& add_ordered_list_entries() const;
  inline ::Impinj::STP::AddOrderedListEntriesResp* mutable_add_ordered_list_entries();
  inline ::Impinj::STP::AddOrderedListEntriesResp* release_add_ordered_list_entries();
  inline void set_allocated_add_ordered_list_entries(::Impinj::STP::AddOrderedListEntriesResp* add_ordered_list_entries);

  // optional .Impinj.STP.SetInventoryJobResp set_inventory_job = 12046;
  inline bool has_set_inventory_job() const;
  inline void clear_set_inventory_job();
  static const int kSetInventoryJobFieldNumber = 12046;
  inline const ::Impinj::STP::SetInventoryJobResp& set_inventory_job() const;
  inline ::Impinj::STP::SetInventoryJobResp* mutable_set_inventory_job();
  inline ::Impinj::STP::SetInventoryJobResp* release_set_inventory_job();
  inline void set_allocated_set_inventory_job(::Impinj::STP::SetInventoryJobResp* set_inventory_job);

  // optional .Impinj.STP.SetCartonContentsJobResp set_carton_contents_job = 12047;
  inline bool has_set_carton_contents_job() const;
  inline void clear_set_carton_contents_job();
  static const int kSetCartonContentsJobFieldNumber = 12047;
  inline const ::Impinj::STP::SetCartonContentsJobResp& set_carton_contents_job() const;
  inline ::Impinj::STP::SetCartonContentsJobResp* mutable_set_carton_contents_job();
  inline ::Impinj::STP::SetCartonContentsJobResp* release_set_carton_contents_job();
  inline void set_allocated_set_carton_contents_job(::Impinj::STP::SetCartonContentsJobResp* set_carton_contents_job);

  // optional .Impinj.STP.GetOperationDataResp get_operation_data = 12048;
  inline bool has_get_operation_data() const;
  inline void clear_get_operation_data();
  static const int kGetOperationDataFieldNumber = 12048;
  inline const ::Impinj::STP::GetOperationDataResp& get_operation_data() const;
  inline ::Impinj::STP::GetOperationDataResp* mutable_get_operation_data();
  inline ::Impinj::STP::GetOperationDataResp* release_get_operation_data();
  inline void set_allocated_get_operation_data(::Impinj::STP::GetOperationDataResp* get_operation_data);

  // optional .Impinj.STP.AddLicenseKeyResp add_license_key = 12049;
  inline bool has_add_license_key() const;
  inline void clear_add_license_key();
  static const int kAddLicenseKeyFieldNumber = 12049;
  inline const ::Impinj::STP::AddLicenseKeyResp& add_license_key() const;
  inline ::Impinj::STP::AddLicenseKeyResp* mutable_add_license_key();
  inline ::Impinj::STP::AddLicenseKeyResp* release_add_license_key();
  inline void set_allocated_add_license_key(::Impinj::STP::AddLicenseKeyResp* add_license_key);

  // @@protoc_insertion_point(class_scope:Impinj.STP.Response)
 private:
  inline void set_has_connect();
  inline void clear_has_connect();
  inline void set_has_get_versions_reader();
  inline void clear_has_get_versions_reader();
  inline void set_has_start();
  inline void clear_has_start();
  inline void set_has_stop();
  inline void clear_has_stop();
  inline void set_has_invalid();
  inline void clear_has_invalid();
  inline void set_has_get_device_state();
  inline void clear_has_get_device_state();
  inline void set_has_set_device_config();
  inline void clear_has_set_device_config();
  inline void set_has_get_device_config();
  inline void clear_has_get_device_config();
  inline void set_has_set_antenna_config();
  inline void clear_has_set_antenna_config();
  inline void set_has_get_antenna_config();
  inline void clear_has_get_antenna_config();
  inline void set_has_engage();
  inline void clear_has_engage();
  inline void set_has_disengage();
  inline void clear_has_disengage();
  inline void set_has_set_operation_result_gpo();
  inline void clear_has_set_operation_result_gpo();
  inline void set_has_add_serialization_job();
  inline void clear_has_add_serialization_job();
  inline void set_has_remove_serialization_job();
  inline void clear_has_remove_serialization_job();
  inline void set_has_add_tid_table_entries();
  inline void clear_has_add_tid_table_entries();
  inline void set_has_add_ordered_list_entries();
  inline void clear_has_add_ordered_list_entries();
  inline void set_has_set_inventory_job();
  inline void clear_has_set_inventory_job();
  inline void set_has_set_carton_contents_job();
  inline void clear_has_set_carton_contents_job();
  inline void set_has_get_operation_data();
  inline void clear_has_get_operation_data();
  inline void set_has_add_license_key();
  inline void clear_has_add_license_key();

  ::Impinj::STP::ConnectResp* connect_;
  ::Impinj::STP::GetVersionsReaderResp* get_versions_reader_;
  ::Impinj::STP::StartResp* start_;
  ::Impinj::STP::StopResp* stop_;
  ::Impinj::STP::InvalidResp* invalid_;
  ::Impinj::STP::GetDeviceStateResp* get_device_state_;
  ::Impinj::STP::SetDeviceConfigResp* set_device_config_;
  ::Impinj::STP::GetDeviceConfigResp* get_device_config_;
  ::Impinj::STP::SetAntennaConfigResp* set_antenna_config_;
  ::Impinj::STP::GetAntennaConfigResp* get_antenna_config_;
  ::Impinj::STP::EngageResp* engage_;
  ::Impinj::STP::DisengageResp* disengage_;
  ::Impinj::STP::SetOperationResultGPOResp* set_operation_result_gpo_;
  ::Impinj::STP::AddSerializationJobResp* add_serialization_job_;
  ::Impinj::STP::RemoveSerializationJobResp* remove_serialization_job_;
  ::Impinj::STP::AddTIDTableEntriesResp* add_tid_table_entries_;
  ::Impinj::STP::AddOrderedListEntriesResp* add_ordered_list_entries_;
  ::Impinj::STP::SetInventoryJobResp* set_inventory_job_;
  ::Impinj::STP::SetCartonContentsJobResp* set_carton_contents_job_;
  ::Impinj::STP::GetOperationDataResp* get_operation_data_;
  ::Impinj::STP::AddLicenseKeyResp* add_license_key_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(21 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static Response* default_instance_;
};
// -------------------------------------------------------------------

class Report : public ::google::protobuf::MessageLite {
 public:
  Report();
  virtual ~Report();

  Report(const Report& from);

  inline Report& operator=(const Report& from) {
    CopyFrom(from);
    return *this;
  }

  static const Report& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const Report* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(Report* other);

  // implements Message ----------------------------------------------

  Report* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const Report& from);
  void MergeFrom(const Report& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .Impinj.STP.DeviceEventReport device_event_report = 1;
  inline bool has_device_event_report() const;
  inline void clear_device_event_report();
  static const int kDeviceEventReportFieldNumber = 1;
  inline const ::Impinj::STP::DeviceEventReport& device_event_report() const;
  inline ::Impinj::STP::DeviceEventReport* mutable_device_event_report();
  inline ::Impinj::STP::DeviceEventReport* release_device_event_report();
  inline void set_allocated_device_event_report(::Impinj::STP::DeviceEventReport* device_event_report);

  // optional .Impinj.STP.TagOperationReport tag_operation_report = 2;
  inline bool has_tag_operation_report() const;
  inline void clear_tag_operation_report();
  static const int kTagOperationReportFieldNumber = 2;
  inline const ::Impinj::STP::TagOperationReport& tag_operation_report() const;
  inline ::Impinj::STP::TagOperationReport* mutable_tag_operation_report();
  inline ::Impinj::STP::TagOperationReport* release_tag_operation_report();
  inline void set_allocated_tag_operation_report(::Impinj::STP::TagOperationReport* tag_operation_report);

  // optional .Impinj.STP.OperationSummaryReport operation_summary_report = 3;
  inline bool has_operation_summary_report() const;
  inline void clear_operation_summary_report();
  static const int kOperationSummaryReportFieldNumber = 3;
  inline const ::Impinj::STP::OperationSummaryReport& operation_summary_report() const;
  inline ::Impinj::STP::OperationSummaryReport* mutable_operation_summary_report();
  inline ::Impinj::STP::OperationSummaryReport* release_operation_summary_report();
  inline void set_allocated_operation_summary_report(::Impinj::STP::OperationSummaryReport* operation_summary_report);

  // optional .Impinj.STP.CartonContentsReport carton_contents_report = 4;
  inline bool has_carton_contents_report() const;
  inline void clear_carton_contents_report();
  static const int kCartonContentsReportFieldNumber = 4;
  inline const ::Impinj::STP::CartonContentsReport& carton_contents_report() const;
  inline ::Impinj::STP::CartonContentsReport* mutable_carton_contents_report();
  inline ::Impinj::STP::CartonContentsReport* release_carton_contents_report();
  inline void set_allocated_carton_contents_report(::Impinj::STP::CartonContentsReport* carton_contents_report);

  // @@protoc_insertion_point(class_scope:Impinj.STP.Report)
 private:
  inline void set_has_device_event_report();
  inline void clear_has_device_event_report();
  inline void set_has_tag_operation_report();
  inline void clear_has_tag_operation_report();
  inline void set_has_operation_summary_report();
  inline void clear_has_operation_summary_report();
  inline void set_has_carton_contents_report();
  inline void clear_has_carton_contents_report();

  ::Impinj::STP::DeviceEventReport* device_event_report_;
  ::Impinj::STP::TagOperationReport* tag_operation_report_;
  ::Impinj::STP::OperationSummaryReport* operation_summary_report_;
  ::Impinj::STP::CartonContentsReport* carton_contents_report_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static Report* default_instance_;
};
// -------------------------------------------------------------------

class Update : public ::google::protobuf::MessageLite {
 public:
  Update();
  virtual ~Update();

  Update(const Update& from);

  inline Update& operator=(const Update& from) {
    CopyFrom(from);
    return *this;
  }

  static const Update& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const Update* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(Update* other);

  // implements Message ----------------------------------------------

  Update* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const Update& from);
  void MergeFrom(const Update& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .Impinj.STP.AddTIDTableEntriesCommand add_tid_table_entries = 1;
  inline bool has_add_tid_table_entries() const;
  inline void clear_add_tid_table_entries();
  static const int kAddTidTableEntriesFieldNumber = 1;
  inline const ::Impinj::STP::AddTIDTableEntriesCommand& add_tid_table_entries() const;
  inline ::Impinj::STP::AddTIDTableEntriesCommand* mutable_add_tid_table_entries();
  inline ::Impinj::STP::AddTIDTableEntriesCommand* release_add_tid_table_entries();
  inline void set_allocated_add_tid_table_entries(::Impinj::STP::AddTIDTableEntriesCommand* add_tid_table_entries);

  // @@protoc_insertion_point(class_scope:Impinj.STP.Update)
 private:
  inline void set_has_add_tid_table_entries();
  inline void clear_has_add_tid_table_entries();

  ::Impinj::STP::AddTIDTableEntriesCommand* add_tid_table_entries_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static Update* default_instance_;
};
// -------------------------------------------------------------------

class Packet : public ::google::protobuf::MessageLite {
 public:
  Packet();
  virtual ~Packet();

  Packet(const Packet& from);

  inline Packet& operator=(const Packet& from) {
    CopyFrom(from);
    return *this;
  }

  static const Packet& default_instance();

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  // Returns the internal default instance pointer. This function can
  // return NULL thus should not be used by the user. This is intended
  // for Protobuf internal code. Please use default_instance() declared
  // above instead.
  static inline const Packet* internal_default_instance() {
    return default_instance_;
  }
  #endif

  void Swap(Packet* other);

  // implements Message ----------------------------------------------

  Packet* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const Packet& from);
  void MergeFrom(const Packet& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::std::string GetTypeName() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .Impinj.STP.Command command = 3;
  inline bool has_command() const;
  inline void clear_command();
  static const int kCommandFieldNumber = 3;
  inline const ::Impinj::STP::Command& command() const;
  inline ::Impinj::STP::Command* mutable_command();
  inline ::Impinj::STP::Command* release_command();
  inline void set_allocated_command(::Impinj::STP::Command* command);

  // optional .Impinj.STP.Response response = 4;
  inline bool has_response() const;
  inline void clear_response();
  static const int kResponseFieldNumber = 4;
  inline const ::Impinj::STP::Response& response() const;
  inline ::Impinj::STP::Response* mutable_response();
  inline ::Impinj::STP::Response* release_response();
  inline void set_allocated_response(::Impinj::STP::Response* response);

  // optional .Impinj.STP.Report report = 5;
  inline bool has_report() const;
  inline void clear_report();
  static const int kReportFieldNumber = 5;
  inline const ::Impinj::STP::Report& report() const;
  inline ::Impinj::STP::Report* mutable_report();
  inline ::Impinj::STP::Report* release_report();
  inline void set_allocated_report(::Impinj::STP::Report* report);

  // optional .Impinj.STP.Update update = 6;
  inline bool has_update() const;
  inline void clear_update();
  static const int kUpdateFieldNumber = 6;
  inline const ::Impinj::STP::Update& update() const;
  inline ::Impinj::STP::Update* mutable_update();
  inline ::Impinj::STP::Update* release_update();
  inline void set_allocated_update(::Impinj::STP::Update* update);

  // @@protoc_insertion_point(class_scope:Impinj.STP.Packet)
 private:
  inline void set_has_command();
  inline void clear_has_command();
  inline void set_has_response();
  inline void clear_has_response();
  inline void set_has_report();
  inline void clear_has_report();
  inline void set_has_update();
  inline void clear_has_update();

  ::Impinj::STP::Command* command_;
  ::Impinj::STP::Response* response_;
  ::Impinj::STP::Report* report_;
  ::Impinj::STP::Update* update_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];

  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  friend void  protobuf_AddDesc_stp_5fapi_2eproto_impl();
  #else
  friend void  protobuf_AddDesc_stp_5fapi_2eproto();
  #endif
  friend void protobuf_AssignDesc_stp_5fapi_2eproto();
  friend void protobuf_ShutdownFile_stp_5fapi_2eproto();

  void InitAsDefaultInstance();
  static Packet* default_instance_;
};
// ===================================================================


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

// Reply

// required .Impinj.STP.ErrorCode error_code = 1;
inline bool Reply::has_error_code() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Reply::set_has_error_code() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Reply::clear_has_error_code() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Reply::clear_error_code() {
  error_code_ = 0;
  clear_has_error_code();
}
inline ::Impinj::STP::ErrorCode Reply::error_code() const {
  return static_cast< ::Impinj::STP::ErrorCode >(error_code_);
}
inline void Reply::set_error_code(::Impinj::STP::ErrorCode value) {
  assert(::Impinj::STP::ErrorCode_IsValid(value));
  set_has_error_code();
  error_code_ = value;
}

// optional string error_string = 2;
inline bool Reply::has_error_string() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void Reply::set_has_error_string() {
  _has_bits_[0] |= 0x00000002u;
}
inline void Reply::clear_has_error_string() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void Reply::clear_error_string() {
  if (error_string_ != &::google::protobuf::internal::kEmptyString) {
    error_string_->clear();
  }
  clear_has_error_string();
}
inline const ::std::string& Reply::error_string() const {
  return *error_string_;
}
inline void Reply::set_error_string(const ::std::string& value) {
  set_has_error_string();
  if (error_string_ == &::google::protobuf::internal::kEmptyString) {
    error_string_ = new ::std::string;
  }
  error_string_->assign(value);
}
inline void Reply::set_error_string(const char* value) {
  set_has_error_string();
  if (error_string_ == &::google::protobuf::internal::kEmptyString) {
    error_string_ = new ::std::string;
  }
  error_string_->assign(value);
}
inline void Reply::set_error_string(const char* value, size_t size) {
  set_has_error_string();
  if (error_string_ == &::google::protobuf::internal::kEmptyString) {
    error_string_ = new ::std::string;
  }
  error_string_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Reply::mutable_error_string() {
  set_has_error_string();
  if (error_string_ == &::google::protobuf::internal::kEmptyString) {
    error_string_ = new ::std::string;
  }
  return error_string_;
}
inline ::std::string* Reply::release_error_string() {
  clear_has_error_string();
  if (error_string_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = error_string_;
    error_string_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void Reply::set_allocated_error_string(::std::string* error_string) {
  if (error_string_ != &::google::protobuf::internal::kEmptyString) {
    delete error_string_;
  }
  if (error_string) {
    set_has_error_string();
    error_string_ = error_string;
  } else {
    clear_has_error_string();
    error_string_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// -------------------------------------------------------------------

// DeviceState

// optional .Impinj.STP.DeviceOperatingState device_operating_state = 1;
inline bool DeviceState::has_device_operating_state() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void DeviceState::set_has_device_operating_state() {
  _has_bits_[0] |= 0x00000001u;
}
inline void DeviceState::clear_has_device_operating_state() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void DeviceState::clear_device_operating_state() {
  device_operating_state_ = 0;
  clear_has_device_operating_state();
}
inline ::Impinj::STP::DeviceOperatingState DeviceState::device_operating_state() const {
  return static_cast< ::Impinj::STP::DeviceOperatingState >(device_operating_state_);
}
inline void DeviceState::set_device_operating_state(::Impinj::STP::DeviceOperatingState value) {
  assert(::Impinj::STP::DeviceOperatingState_IsValid(value));
  set_has_device_operating_state();
  device_operating_state_ = value;
}

// optional .Impinj.STP.DeviceFaultType device_fault = 2;
inline bool DeviceState::has_device_fault() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void DeviceState::set_has_device_fault() {
  _has_bits_[0] |= 0x00000002u;
}
inline void DeviceState::clear_has_device_fault() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void DeviceState::clear_device_fault() {
  device_fault_ = 0;
  clear_has_device_fault();
}
inline ::Impinj::STP::DeviceFaultType DeviceState::device_fault() const {
  return static_cast< ::Impinj::STP::DeviceFaultType >(device_fault_);
}
inline void DeviceState::set_device_fault(::Impinj::STP::DeviceFaultType value) {
  assert(::Impinj::STP::DeviceFaultType_IsValid(value));
  set_has_device_fault();
  device_fault_ = value;
}

// optional string fault_details = 3;
inline bool DeviceState::has_fault_details() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void DeviceState::set_has_fault_details() {
  _has_bits_[0] |= 0x00000004u;
}
inline void DeviceState::clear_has_fault_details() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void DeviceState::clear_fault_details() {
  if (fault_details_ != &::google::protobuf::internal::kEmptyString) {
    fault_details_->clear();
  }
  clear_has_fault_details();
}
inline const ::std::string& DeviceState::fault_details() const {
  return *fault_details_;
}
inline void DeviceState::set_fault_details(const ::std::string& value) {
  set_has_fault_details();
  if (fault_details_ == &::google::protobuf::internal::kEmptyString) {
    fault_details_ = new ::std::string;
  }
  fault_details_->assign(value);
}
inline void DeviceState::set_fault_details(const char* value) {
  set_has_fault_details();
  if (fault_details_ == &::google::protobuf::internal::kEmptyString) {
    fault_details_ = new ::std::string;
  }
  fault_details_->assign(value);
}
inline void DeviceState::set_fault_details(const char* value, size_t size) {
  set_has_fault_details();
  if (fault_details_ == &::google::protobuf::internal::kEmptyString) {
    fault_details_ = new ::std::string;
  }
  fault_details_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* DeviceState::mutable_fault_details() {
  set_has_fault_details();
  if (fault_details_ == &::google::protobuf::internal::kEmptyString) {
    fault_details_ = new ::std::string;
  }
  return fault_details_;
}
inline ::std::string* DeviceState::release_fault_details() {
  clear_has_fault_details();
  if (fault_details_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = fault_details_;
    fault_details_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void DeviceState::set_allocated_fault_details(::std::string* fault_details) {
  if (fault_details_ != &::google::protobuf::internal::kEmptyString) {
    delete fault_details_;
  }
  if (fault_details) {
    set_has_fault_details();
    fault_details_ = fault_details;
  } else {
    clear_has_fault_details();
    fault_details_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// -------------------------------------------------------------------

// Version

// required .Impinj.STP.VersionType version_ID = 1;
inline bool Version::has_version_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Version::set_has_version_id() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Version::clear_has_version_id() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Version::clear_version_id() {
  version_id_ = 0;
  clear_has_version_id();
}
inline ::Impinj::STP::VersionType Version::version_id() const {
  return static_cast< ::Impinj::STP::VersionType >(version_id_);
}
inline void Version::set_version_id(::Impinj::STP::VersionType value) {
  assert(::Impinj::STP::VersionType_IsValid(value));
  set_has_version_id();
  version_id_ = value;
}

// optional uint32 major = 2;
inline bool Version::has_major() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void Version::set_has_major() {
  _has_bits_[0] |= 0x00000002u;
}
inline void Version::clear_has_major() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void Version::clear_major() {
  major_ = 0u;
  clear_has_major();
}
inline ::google::protobuf::uint32 Version::major() const {
  return major_;
}
inline void Version::set_major(::google::protobuf::uint32 value) {
  set_has_major();
  major_ = value;
}

// optional uint32 minor = 3;
inline bool Version::has_minor() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void Version::set_has_minor() {
  _has_bits_[0] |= 0x00000004u;
}
inline void Version::clear_has_minor() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void Version::clear_minor() {
  minor_ = 0u;
  clear_has_minor();
}
inline ::google::protobuf::uint32 Version::minor() const {
  return minor_;
}
inline void Version::set_minor(::google::protobuf::uint32 value) {
  set_has_minor();
  minor_ = value;
}

// optional uint32 maintenance = 4;
inline bool Version::has_maintenance() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void Version::set_has_maintenance() {
  _has_bits_[0] |= 0x00000008u;
}
inline void Version::clear_has_maintenance() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void Version::clear_maintenance() {
  maintenance_ = 0u;
  clear_has_maintenance();
}
inline ::google::protobuf::uint32 Version::maintenance() const {
  return maintenance_;
}
inline void Version::set_maintenance(::google::protobuf::uint32 value) {
  set_has_maintenance();
  maintenance_ = value;
}

// optional uint32 build = 5;
inline bool Version::has_build() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void Version::set_has_build() {
  _has_bits_[0] |= 0x00000010u;
}
inline void Version::clear_has_build() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void Version::clear_build() {
  build_ = 0u;
  clear_has_build();
}
inline ::google::protobuf::uint32 Version::build() const {
  return build_;
}
inline void Version::set_build(::google::protobuf::uint32 value) {
  set_has_build();
  build_ = value;
}

// optional string ident = 6;
inline bool Version::has_ident() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void Version::set_has_ident() {
  _has_bits_[0] |= 0x00000020u;
}
inline void Version::clear_has_ident() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void Version::clear_ident() {
  if (ident_ != &::google::protobuf::internal::kEmptyString) {
    ident_->clear();
  }
  clear_has_ident();
}
inline const ::std::string& Version::ident() const {
  return *ident_;
}
inline void Version::set_ident(const ::std::string& value) {
  set_has_ident();
  if (ident_ == &::google::protobuf::internal::kEmptyString) {
    ident_ = new ::std::string;
  }
  ident_->assign(value);
}
inline void Version::set_ident(const char* value) {
  set_has_ident();
  if (ident_ == &::google::protobuf::internal::kEmptyString) {
    ident_ = new ::std::string;
  }
  ident_->assign(value);
}
inline void Version::set_ident(const char* value, size_t size) {
  set_has_ident();
  if (ident_ == &::google::protobuf::internal::kEmptyString) {
    ident_ = new ::std::string;
  }
  ident_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Version::mutable_ident() {
  set_has_ident();
  if (ident_ == &::google::protobuf::internal::kEmptyString) {
    ident_ = new ::std::string;
  }
  return ident_;
}
inline ::std::string* Version::release_ident() {
  clear_has_ident();
  if (ident_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = ident_;
    ident_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void Version::set_allocated_ident(::std::string* ident) {
  if (ident_ != &::google::protobuf::internal::kEmptyString) {
    delete ident_;
  }
  if (ident) {
    set_has_ident();
    ident_ = ident;
  } else {
    clear_has_ident();
    ident_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// -------------------------------------------------------------------

// Versions

// repeated .Impinj.STP.Version version_list = 1;
inline int Versions::version_list_size() const {
  return version_list_.size();
}
inline void Versions::clear_version_list() {
  version_list_.Clear();
}
inline const ::Impinj::STP::Version& Versions::version_list(int index) const {
  return version_list_.Get(index);
}
inline ::Impinj::STP::Version* Versions::mutable_version_list(int index) {
  return version_list_.Mutable(index);
}
inline ::Impinj::STP::Version* Versions::add_version_list() {
  return version_list_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::Impinj::STP::Version >&
Versions::version_list() const {
  return version_list_;
}
inline ::google::protobuf::RepeatedPtrField< ::Impinj::STP::Version >*
Versions::mutable_version_list() {
  return &version_list_;
}

// -------------------------------------------------------------------

// HandShake

// required string API_name = 1;
inline bool HandShake::has_api_name() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void HandShake::set_has_api_name() {
  _has_bits_[0] |= 0x00000001u;
}
inline void HandShake::clear_has_api_name() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void HandShake::clear_api_name() {
  if (api_name_ != &::google::protobuf::internal::kEmptyString) {
    api_name_->clear();
  }
  clear_has_api_name();
}
inline const ::std::string& HandShake::api_name() const {
  return *api_name_;
}
inline void HandShake::set_api_name(const ::std::string& value) {
  set_has_api_name();
  if (api_name_ == &::google::protobuf::internal::kEmptyString) {
    api_name_ = new ::std::string;
  }
  api_name_->assign(value);
}
inline void HandShake::set_api_name(const char* value) {
  set_has_api_name();
  if (api_name_ == &::google::protobuf::internal::kEmptyString) {
    api_name_ = new ::std::string;
  }
  api_name_->assign(value);
}
inline void HandShake::set_api_name(const char* value, size_t size) {
  set_has_api_name();
  if (api_name_ == &::google::protobuf::internal::kEmptyString) {
    api_name_ = new ::std::string;
  }
  api_name_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* HandShake::mutable_api_name() {
  set_has_api_name();
  if (api_name_ == &::google::protobuf::internal::kEmptyString) {
    api_name_ = new ::std::string;
  }
  return api_name_;
}
inline ::std::string* HandShake::release_api_name() {
  clear_has_api_name();
  if (api_name_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = api_name_;
    api_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void HandShake::set_allocated_api_name(::std::string* api_name) {
  if (api_name_ != &::google::protobuf::internal::kEmptyString) {
    delete api_name_;
  }
  if (api_name) {
    set_has_api_name();
    api_name_ = api_name;
  } else {
    clear_has_api_name();
    api_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// required uint32 API_version = 2;
inline bool HandShake::has_api_version() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void HandShake::set_has_api_version() {
  _has_bits_[0] |= 0x00000002u;
}
inline void HandShake::clear_has_api_version() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void HandShake::clear_api_version() {
  api_version_ = 0u;
  clear_has_api_version();
}
inline ::google::protobuf::uint32 HandShake::api_version() const {
  return api_version_;
}
inline void HandShake::set_api_version(::google::protobuf::uint32 value) {
  set_has_api_version();
  api_version_ = value;
}

// -------------------------------------------------------------------

// Region

// required .Impinj.STP.RegulatoryRegion region_id = 1 [default = REGULATORY_REGION_FCC_PART_15_247];
inline bool Region::has_region_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Region::set_has_region_id() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Region::clear_has_region_id() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Region::clear_region_id() {
  region_id_ = 0;
  clear_has_region_id();
}
inline ::Impinj::STP::RegulatoryRegion Region::region_id() const {
  return static_cast< ::Impinj::STP::RegulatoryRegion >(region_id_);
}
inline void Region::set_region_id(::Impinj::STP::RegulatoryRegion value) {
  assert(::Impinj::STP::RegulatoryRegion_IsValid(value));
  set_has_region_id();
  region_id_ = value;
}

// repeated uint32 fixed_frequency_list = 2;
inline int Region::fixed_frequency_list_size() const {
  return fixed_frequency_list_.size();
}
inline void Region::clear_fixed_frequency_list() {
  fixed_frequency_list_.Clear();
}
inline ::google::protobuf::uint32 Region::fixed_frequency_list(int index) const {
  return fixed_frequency_list_.Get(index);
}
inline void Region::set_fixed_frequency_list(int index, ::google::protobuf::uint32 value) {
  fixed_frequency_list_.Set(index, value);
}
inline void Region::add_fixed_frequency_list(::google::protobuf::uint32 value) {
  fixed_frequency_list_.Add(value);
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
Region::fixed_frequency_list() const {
  return fixed_frequency_list_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
Region::mutable_fixed_frequency_list() {
  return &fixed_frequency_list_;
}

// -------------------------------------------------------------------

// Timestamp

// optional uint64 useconds_since_epoch = 1;
inline bool Timestamp::has_useconds_since_epoch() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Timestamp::set_has_useconds_since_epoch() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Timestamp::clear_has_useconds_since_epoch() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Timestamp::clear_useconds_since_epoch() {
  useconds_since_epoch_ = GOOGLE_ULONGLONG(0);
  clear_has_useconds_since_epoch();
}
inline ::google::protobuf::uint64 Timestamp::useconds_since_epoch() const {
  return useconds_since_epoch_;
}
inline void Timestamp::set_useconds_since_epoch(::google::protobuf::uint64 value) {
  set_has_useconds_since_epoch();
  useconds_since_epoch_ = value;
}

// -------------------------------------------------------------------

// ConnectCommand

// optional .Impinj.STP.HandShake hand_shake = 1;
inline bool ConnectCommand::has_hand_shake() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ConnectCommand::set_has_hand_shake() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ConnectCommand::clear_has_hand_shake() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ConnectCommand::clear_hand_shake() {
  if (hand_shake_ != NULL) hand_shake_->::Impinj::STP::HandShake::Clear();
  clear_has_hand_shake();
}
inline const ::Impinj::STP::HandShake& ConnectCommand::hand_shake() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return hand_shake_ != NULL ? *hand_shake_ : *default_instance().hand_shake_;
#else
  return hand_shake_ != NULL ? *hand_shake_ : *default_instance_->hand_shake_;
#endif
}
inline ::Impinj::STP::HandShake* ConnectCommand::mutable_hand_shake() {
  set_has_hand_shake();
  if (hand_shake_ == NULL) hand_shake_ = new ::Impinj::STP::HandShake;
  return hand_shake_;
}
inline ::Impinj::STP::HandShake* ConnectCommand::release_hand_shake() {
  clear_has_hand_shake();
  ::Impinj::STP::HandShake* temp = hand_shake_;
  hand_shake_ = NULL;
  return temp;
}
inline void ConnectCommand::set_allocated_hand_shake(::Impinj::STP::HandShake* hand_shake) {
  delete hand_shake_;
  hand_shake_ = hand_shake;
  if (hand_shake) {
    set_has_hand_shake();
  } else {
    clear_has_hand_shake();
  }
}

// -------------------------------------------------------------------

// GetDeviceStateCommand

// optional bool reserved = 1;
inline bool GetDeviceStateCommand::has_reserved() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GetDeviceStateCommand::set_has_reserved() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GetDeviceStateCommand::clear_has_reserved() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GetDeviceStateCommand::clear_reserved() {
  reserved_ = false;
  clear_has_reserved();
}
inline bool GetDeviceStateCommand::reserved() const {
  return reserved_;
}
inline void GetDeviceStateCommand::set_reserved(bool value) {
  set_has_reserved();
  reserved_ = value;
}

// -------------------------------------------------------------------

// GetVersionsReaderCommand

// optional bool reserved = 1;
inline bool GetVersionsReaderCommand::has_reserved() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GetVersionsReaderCommand::set_has_reserved() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GetVersionsReaderCommand::clear_has_reserved() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GetVersionsReaderCommand::clear_reserved() {
  reserved_ = false;
  clear_has_reserved();
}
inline bool GetVersionsReaderCommand::reserved() const {
  return reserved_;
}
inline void GetVersionsReaderCommand::set_reserved(bool value) {
  set_has_reserved();
  reserved_ = value;
}

// -------------------------------------------------------------------

// StopCommand

// optional bool reserved = 1;
inline bool StopCommand::has_reserved() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void StopCommand::set_has_reserved() {
  _has_bits_[0] |= 0x00000001u;
}
inline void StopCommand::clear_has_reserved() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void StopCommand::clear_reserved() {
  reserved_ = false;
  clear_has_reserved();
}
inline bool StopCommand::reserved() const {
  return reserved_;
}
inline void StopCommand::set_reserved(bool value) {
  set_has_reserved();
  reserved_ = value;
}

// -------------------------------------------------------------------

// ConnectResp

// optional .Impinj.STP.Reply reply = 1;
inline bool ConnectResp::has_reply() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ConnectResp::set_has_reply() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ConnectResp::clear_has_reply() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ConnectResp::clear_reply() {
  if (reply_ != NULL) reply_->::Impinj::STP::Reply::Clear();
  clear_has_reply();
}
inline const ::Impinj::STP::Reply& ConnectResp::reply() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return reply_ != NULL ? *reply_ : *default_instance().reply_;
#else
  return reply_ != NULL ? *reply_ : *default_instance_->reply_;
#endif
}
inline ::Impinj::STP::Reply* ConnectResp::mutable_reply() {
  set_has_reply();
  if (reply_ == NULL) reply_ = new ::Impinj::STP::Reply;
  return reply_;
}
inline ::Impinj::STP::Reply* ConnectResp::release_reply() {
  clear_has_reply();
  ::Impinj::STP::Reply* temp = reply_;
  reply_ = NULL;
  return temp;
}
inline void ConnectResp::set_allocated_reply(::Impinj::STP::Reply* reply) {
  delete reply_;
  reply_ = reply;
  if (reply) {
    set_has_reply();
  } else {
    clear_has_reply();
  }
}

// optional .Impinj.STP.HandShake hand_shake = 2;
inline bool ConnectResp::has_hand_shake() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ConnectResp::set_has_hand_shake() {
  _has_bits_[0] |= 0x00000002u;
}
inline void ConnectResp::clear_has_hand_shake() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void ConnectResp::clear_hand_shake() {
  if (hand_shake_ != NULL) hand_shake_->::Impinj::STP::HandShake::Clear();
  clear_has_hand_shake();
}
inline const ::Impinj::STP::HandShake& ConnectResp::hand_shake() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return hand_shake_ != NULL ? *hand_shake_ : *default_instance().hand_shake_;
#else
  return hand_shake_ != NULL ? *hand_shake_ : *default_instance_->hand_shake_;
#endif
}
inline ::Impinj::STP::HandShake* ConnectResp::mutable_hand_shake() {
  set_has_hand_shake();
  if (hand_shake_ == NULL) hand_shake_ = new ::Impinj::STP::HandShake;
  return hand_shake_;
}
inline ::Impinj::STP::HandShake* ConnectResp::release_hand_shake() {
  clear_has_hand_shake();
  ::Impinj::STP::HandShake* temp = hand_shake_;
  hand_shake_ = NULL;
  return temp;
}
inline void ConnectResp::set_allocated_hand_shake(::Impinj::STP::HandShake* hand_shake) {
  delete hand_shake_;
  hand_shake_ = hand_shake;
  if (hand_shake) {
    set_has_hand_shake();
  } else {
    clear_has_hand_shake();
  }
}

// -------------------------------------------------------------------

// GetDeviceStateResp

// optional .Impinj.STP.Reply reply = 1;
inline bool GetDeviceStateResp::has_reply() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GetDeviceStateResp::set_has_reply() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GetDeviceStateResp::clear_has_reply() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GetDeviceStateResp::clear_reply() {
  if (reply_ != NULL) reply_->::Impinj::STP::Reply::Clear();
  clear_has_reply();
}
inline const ::Impinj::STP::Reply& GetDeviceStateResp::reply() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return reply_ != NULL ? *reply_ : *default_instance().reply_;
#else
  return reply_ != NULL ? *reply_ : *default_instance_->reply_;
#endif
}
inline ::Impinj::STP::Reply* GetDeviceStateResp::mutable_reply() {
  set_has_reply();
  if (reply_ == NULL) reply_ = new ::Impinj::STP::Reply;
  return reply_;
}
inline ::Impinj::STP::Reply* GetDeviceStateResp::release_reply() {
  clear_has_reply();
  ::Impinj::STP::Reply* temp = reply_;
  reply_ = NULL;
  return temp;
}
inline void GetDeviceStateResp::set_allocated_reply(::Impinj::STP::Reply* reply) {
  delete reply_;
  reply_ = reply;
  if (reply) {
    set_has_reply();
  } else {
    clear_has_reply();
  }
}

// optional .Impinj.STP.DeviceState device_state = 2;
inline bool GetDeviceStateResp::has_device_state() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void GetDeviceStateResp::set_has_device_state() {
  _has_bits_[0] |= 0x00000002u;
}
inline void GetDeviceStateResp::clear_has_device_state() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void GetDeviceStateResp::clear_device_state() {
  if (device_state_ != NULL) device_state_->::Impinj::STP::DeviceState::Clear();
  clear_has_device_state();
}
inline const ::Impinj::STP::DeviceState& GetDeviceStateResp::device_state() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return device_state_ != NULL ? *device_state_ : *default_instance().device_state_;
#else
  return device_state_ != NULL ? *device_state_ : *default_instance_->device_state_;
#endif
}
inline ::Impinj::STP::DeviceState* GetDeviceStateResp::mutable_device_state() {
  set_has_device_state();
  if (device_state_ == NULL) device_state_ = new ::Impinj::STP::DeviceState;
  return device_state_;
}
inline ::Impinj::STP::DeviceState* GetDeviceStateResp::release_device_state() {
  clear_has_device_state();
  ::Impinj::STP::DeviceState* temp = device_state_;
  device_state_ = NULL;
  return temp;
}
inline void GetDeviceStateResp::set_allocated_device_state(::Impinj::STP::DeviceState* device_state) {
  delete device_state_;
  device_state_ = device_state;
  if (device_state) {
    set_has_device_state();
  } else {
    clear_has_device_state();
  }
}

// -------------------------------------------------------------------

// GetVersionsReaderResp

// optional .Impinj.STP.Reply reply = 1;
inline bool GetVersionsReaderResp::has_reply() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GetVersionsReaderResp::set_has_reply() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GetVersionsReaderResp::clear_has_reply() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GetVersionsReaderResp::clear_reply() {
  if (reply_ != NULL) reply_->::Impinj::STP::Reply::Clear();
  clear_has_reply();
}
inline const ::Impinj::STP::Reply& GetVersionsReaderResp::reply() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return reply_ != NULL ? *reply_ : *default_instance().reply_;
#else
  return reply_ != NULL ? *reply_ : *default_instance_->reply_;
#endif
}
inline ::Impinj::STP::Reply* GetVersionsReaderResp::mutable_reply() {
  set_has_reply();
  if (reply_ == NULL) reply_ = new ::Impinj::STP::Reply;
  return reply_;
}
inline ::Impinj::STP::Reply* GetVersionsReaderResp::release_reply() {
  clear_has_reply();
  ::Impinj::STP::Reply* temp = reply_;
  reply_ = NULL;
  return temp;
}
inline void GetVersionsReaderResp::set_allocated_reply(::Impinj::STP::Reply* reply) {
  delete reply_;
  reply_ = reply;
  if (reply) {
    set_has_reply();
  } else {
    clear_has_reply();
  }
}

// optional .Impinj.STP.Versions versions = 2;
inline bool GetVersionsReaderResp::has_versions() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void GetVersionsReaderResp::set_has_versions() {
  _has_bits_[0] |= 0x00000002u;
}
inline void GetVersionsReaderResp::clear_has_versions() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void GetVersionsReaderResp::clear_versions() {
  if (versions_ != NULL) versions_->::Impinj::STP::Versions::Clear();
  clear_has_versions();
}
inline const ::Impinj::STP::Versions& GetVersionsReaderResp::versions() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return versions_ != NULL ? *versions_ : *default_instance().versions_;
#else
  return versions_ != NULL ? *versions_ : *default_instance_->versions_;
#endif
}
inline ::Impinj::STP::Versions* GetVersionsReaderResp::mutable_versions() {
  set_has_versions();
  if (versions_ == NULL) versions_ = new ::Impinj::STP::Versions;
  return versions_;
}
inline ::Impinj::STP::Versions* GetVersionsReaderResp::release_versions() {
  clear_has_versions();
  ::Impinj::STP::Versions* temp = versions_;
  versions_ = NULL;
  return temp;
}
inline void GetVersionsReaderResp::set_allocated_versions(::Impinj::STP::Versions* versions) {
  delete versions_;
  versions_ = versions;
  if (versions) {
    set_has_versions();
  } else {
    clear_has_versions();
  }
}

// -------------------------------------------------------------------

// InvalidResp

// optional bool reserved = 1;
inline bool InvalidResp::has_reserved() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void InvalidResp::set_has_reserved() {
  _has_bits_[0] |= 0x00000001u;
}
inline void InvalidResp::clear_has_reserved() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void InvalidResp::clear_reserved() {
  reserved_ = false;
  clear_has_reserved();
}
inline bool InvalidResp::reserved() const {
  return reserved_;
}
inline void InvalidResp::set_reserved(bool value) {
  set_has_reserved();
  reserved_ = value;
}

// -------------------------------------------------------------------

// StopResp

// optional .Impinj.STP.Reply reply = 1;
inline bool StopResp::has_reply() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void StopResp::set_has_reply() {
  _has_bits_[0] |= 0x00000001u;
}
inline void StopResp::clear_has_reply() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void StopResp::clear_reply() {
  if (reply_ != NULL) reply_->::Impinj::STP::Reply::Clear();
  clear_has_reply();
}
inline const ::Impinj::STP::Reply& StopResp::reply() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return reply_ != NULL ? *reply_ : *default_instance().reply_;
#else
  return reply_ != NULL ? *reply_ : *default_instance_->reply_;
#endif
}
inline ::Impinj::STP::Reply* StopResp::mutable_reply() {
  set_has_reply();
  if (reply_ == NULL) reply_ = new ::Impinj::STP::Reply;
  return reply_;
}
inline ::Impinj::STP::Reply* StopResp::release_reply() {
  clear_has_reply();
  ::Impinj::STP::Reply* temp = reply_;
  reply_ = NULL;
  return temp;
}
inline void StopResp::set_allocated_reply(::Impinj::STP::Reply* reply) {
  delete reply_;
  reply_ = reply;
  if (reply) {
    set_has_reply();
  } else {
    clear_has_reply();
  }
}

// -------------------------------------------------------------------

// DeviceConfig

// optional .Impinj.STP.Region region = 2;
inline bool DeviceConfig::has_region() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void DeviceConfig::set_has_region() {
  _has_bits_[0] |= 0x00000001u;
}
inline void DeviceConfig::clear_has_region() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void DeviceConfig::clear_region() {
  if (region_ != NULL) region_->::Impinj::STP::Region::Clear();
  clear_has_region();
}
inline const ::Impinj::STP::Region& DeviceConfig::region() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return region_ != NULL ? *region_ : *default_instance().region_;
#else
  return region_ != NULL ? *region_ : *default_instance_->region_;
#endif
}
inline ::Impinj::STP::Region* DeviceConfig::mutable_region() {
  set_has_region();
  if (region_ == NULL) region_ = new ::Impinj::STP::Region;
  return region_;
}
inline ::Impinj::STP::Region* DeviceConfig::release_region() {
  clear_has_region();
  ::Impinj::STP::Region* temp = region_;
  region_ = NULL;
  return temp;
}
inline void DeviceConfig::set_allocated_region(::Impinj::STP::Region* region) {
  delete region_;
  region_ = region;
  if (region) {
    set_has_region();
  } else {
    clear_has_region();
  }
}

// required .Impinj.STP.DeviceMode device_mode = 3 [default = DEVICE_MODE_INVENTORY];
inline bool DeviceConfig::has_device_mode() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void DeviceConfig::set_has_device_mode() {
  _has_bits_[0] |= 0x00000002u;
}
inline void DeviceConfig::clear_has_device_mode() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void DeviceConfig::clear_device_mode() {
  device_mode_ = 0;
  clear_has_device_mode();
}
inline ::Impinj::STP::DeviceMode DeviceConfig::device_mode() const {
  return static_cast< ::Impinj::STP::DeviceMode >(device_mode_);
}
inline void DeviceConfig::set_device_mode(::Impinj::STP::DeviceMode value) {
  assert(::Impinj::STP::DeviceMode_IsValid(value));
  set_has_device_mode();
  device_mode_ = value;
}

// required .Impinj.STP.OperationMode operation_mode = 4 [default = OPERATION_MODE_CONTINUOUS];
inline bool DeviceConfig::has_operation_mode() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void DeviceConfig::set_has_operation_mode() {
  _has_bits_[0] |= 0x00000004u;
}
inline void DeviceConfig::clear_has_operation_mode() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void DeviceConfig::clear_operation_mode() {
  operation_mode_ = 2;
  clear_has_operation_mode();
}
inline ::Impinj::STP::OperationMode DeviceConfig::operation_mode() const {
  return static_cast< ::Impinj::STP::OperationMode >(operation_mode_);
}
inline void DeviceConfig::set_operation_mode(::Impinj::STP::OperationMode value) {
  assert(::Impinj::STP::OperationMode_IsValid(value));
  set_has_operation_mode();
  operation_mode_ = value;
}

// optional .Impinj.STP.OperationResponsibility operation_responsibility = 5;
inline bool DeviceConfig::has_operation_responsibility() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void DeviceConfig::set_has_operation_responsibility() {
  _has_bits_[0] |= 0x00000008u;
}
inline void DeviceConfig::clear_has_operation_responsibility() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void DeviceConfig::clear_operation_responsibility() {
  if (operation_responsibility_ != NULL) operation_responsibility_->::Impinj::STP::OperationResponsibility::Clear();
  clear_has_operation_responsibility();
}
inline const ::Impinj::STP::OperationResponsibility& DeviceConfig::operation_responsibility() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return operation_responsibility_ != NULL ? *operation_responsibility_ : *default_instance().operation_responsibility_;
#else
  return operation_responsibility_ != NULL ? *operation_responsibility_ : *default_instance_->operation_responsibility_;
#endif
}
inline ::Impinj::STP::OperationResponsibility* DeviceConfig::mutable_operation_responsibility() {
  set_has_operation_responsibility();
  if (operation_responsibility_ == NULL) operation_responsibility_ = new ::Impinj::STP::OperationResponsibility;
  return operation_responsibility_;
}
inline ::Impinj::STP::OperationResponsibility* DeviceConfig::release_operation_responsibility() {
  clear_has_operation_responsibility();
  ::Impinj::STP::OperationResponsibility* temp = operation_responsibility_;
  operation_responsibility_ = NULL;
  return temp;
}
inline void DeviceConfig::set_allocated_operation_responsibility(::Impinj::STP::OperationResponsibility* operation_responsibility) {
  delete operation_responsibility_;
  operation_responsibility_ = operation_responsibility;
  if (operation_responsibility) {
    set_has_operation_responsibility();
  } else {
    clear_has_operation_responsibility();
  }
}

// optional .Impinj.STP.TriggerConfig trigger_config = 6;
inline bool DeviceConfig::has_trigger_config() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void DeviceConfig::set_has_trigger_config() {
  _has_bits_[0] |= 0x00000010u;
}
inline void DeviceConfig::clear_has_trigger_config() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void DeviceConfig::clear_trigger_config() {
  if (trigger_config_ != NULL) trigger_config_->::Impinj::STP::TriggerConfig::Clear();
  clear_has_trigger_config();
}
inline const ::Impinj::STP::TriggerConfig& DeviceConfig::trigger_config() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return trigger_config_ != NULL ? *trigger_config_ : *default_instance().trigger_config_;
#else
  return trigger_config_ != NULL ? *trigger_config_ : *default_instance_->trigger_config_;
#endif
}
inline ::Impinj::STP::TriggerConfig* DeviceConfig::mutable_trigger_config() {
  set_has_trigger_config();
  if (trigger_config_ == NULL) trigger_config_ = new ::Impinj::STP::TriggerConfig;
  return trigger_config_;
}
inline ::Impinj::STP::TriggerConfig* DeviceConfig::release_trigger_config() {
  clear_has_trigger_config();
  ::Impinj::STP::TriggerConfig* temp = trigger_config_;
  trigger_config_ = NULL;
  return temp;
}
inline void DeviceConfig::set_allocated_trigger_config(::Impinj::STP::TriggerConfig* trigger_config) {
  delete trigger_config_;
  trigger_config_ = trigger_config;
  if (trigger_config) {
    set_has_trigger_config();
  } else {
    clear_has_trigger_config();
  }
}

// optional .Impinj.STP.GPIConfig GPI_config = 7;
inline bool DeviceConfig::has_gpi_config() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void DeviceConfig::set_has_gpi_config() {
  _has_bits_[0] |= 0x00000020u;
}
inline void DeviceConfig::clear_has_gpi_config() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void DeviceConfig::clear_gpi_config() {
  if (gpi_config_ != NULL) gpi_config_->::Impinj::STP::GPIConfig::Clear();
  clear_has_gpi_config();
}
inline const ::Impinj::STP::GPIConfig& DeviceConfig::gpi_config() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return gpi_config_ != NULL ? *gpi_config_ : *default_instance().gpi_config_;
#else
  return gpi_config_ != NULL ? *gpi_config_ : *default_instance_->gpi_config_;
#endif
}
inline ::Impinj::STP::GPIConfig* DeviceConfig::mutable_gpi_config() {
  set_has_gpi_config();
  if (gpi_config_ == NULL) gpi_config_ = new ::Impinj::STP::GPIConfig;
  return gpi_config_;
}
inline ::Impinj::STP::GPIConfig* DeviceConfig::release_gpi_config() {
  clear_has_gpi_config();
  ::Impinj::STP::GPIConfig* temp = gpi_config_;
  gpi_config_ = NULL;
  return temp;
}
inline void DeviceConfig::set_allocated_gpi_config(::Impinj::STP::GPIConfig* gpi_config) {
  delete gpi_config_;
  gpi_config_ = gpi_config;
  if (gpi_config) {
    set_has_gpi_config();
  } else {
    clear_has_gpi_config();
  }
}

// optional .Impinj.STP.GPOConfig GPO_config = 8;
inline bool DeviceConfig::has_gpo_config() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void DeviceConfig::set_has_gpo_config() {
  _has_bits_[0] |= 0x00000040u;
}
inline void DeviceConfig::clear_has_gpo_config() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void DeviceConfig::clear_gpo_config() {
  if (gpo_config_ != NULL) gpo_config_->::Impinj::STP::GPOConfig::Clear();
  clear_has_gpo_config();
}
inline const ::Impinj::STP::GPOConfig& DeviceConfig::gpo_config() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return gpo_config_ != NULL ? *gpo_config_ : *default_instance().gpo_config_;
#else
  return gpo_config_ != NULL ? *gpo_config_ : *default_instance_->gpo_config_;
#endif
}
inline ::Impinj::STP::GPOConfig* DeviceConfig::mutable_gpo_config() {
  set_has_gpo_config();
  if (gpo_config_ == NULL) gpo_config_ = new ::Impinj::STP::GPOConfig;
  return gpo_config_;
}
inline ::Impinj::STP::GPOConfig* DeviceConfig::release_gpo_config() {
  clear_has_gpo_config();
  ::Impinj::STP::GPOConfig* temp = gpo_config_;
  gpo_config_ = NULL;
  return temp;
}
inline void DeviceConfig::set_allocated_gpo_config(::Impinj::STP::GPOConfig* gpo_config) {
  delete gpo_config_;
  gpo_config_ = gpo_config;
  if (gpo_config) {
    set_has_gpo_config();
  } else {
    clear_has_gpo_config();
  }
}

// optional .Impinj.STP.ReportConfig report_config = 9;
inline bool DeviceConfig::has_report_config() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void DeviceConfig::set_has_report_config() {
  _has_bits_[0] |= 0x00000080u;
}
inline void DeviceConfig::clear_has_report_config() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void DeviceConfig::clear_report_config() {
  if (report_config_ != NULL) report_config_->::Impinj::STP::ReportConfig::Clear();
  clear_has_report_config();
}
inline const ::Impinj::STP::ReportConfig& DeviceConfig::report_config() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return report_config_ != NULL ? *report_config_ : *default_instance().report_config_;
#else
  return report_config_ != NULL ? *report_config_ : *default_instance_->report_config_;
#endif
}
inline ::Impinj::STP::ReportConfig* DeviceConfig::mutable_report_config() {
  set_has_report_config();
  if (report_config_ == NULL) report_config_ = new ::Impinj::STP::ReportConfig;
  return report_config_;
}
inline ::Impinj::STP::ReportConfig* DeviceConfig::release_report_config() {
  clear_has_report_config();
  ::Impinj::STP::ReportConfig* temp = report_config_;
  report_config_ = NULL;
  return temp;
}
inline void DeviceConfig::set_allocated_report_config(::Impinj::STP::ReportConfig* report_config) {
  delete report_config_;
  report_config_ = report_config;
  if (report_config) {
    set_has_report_config();
  } else {
    clear_has_report_config();
  }
}

// -------------------------------------------------------------------

// TriggerConfig

// optional .Impinj.STP.StartTriggerConfig start_trigger_config = 1;
inline bool TriggerConfig::has_start_trigger_config() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TriggerConfig::set_has_start_trigger_config() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TriggerConfig::clear_has_start_trigger_config() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TriggerConfig::clear_start_trigger_config() {
  if (start_trigger_config_ != NULL) start_trigger_config_->::Impinj::STP::StartTriggerConfig::Clear();
  clear_has_start_trigger_config();
}
inline const ::Impinj::STP::StartTriggerConfig& TriggerConfig::start_trigger_config() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return start_trigger_config_ != NULL ? *start_trigger_config_ : *default_instance().start_trigger_config_;
#else
  return start_trigger_config_ != NULL ? *start_trigger_config_ : *default_instance_->start_trigger_config_;
#endif
}
inline ::Impinj::STP::StartTriggerConfig* TriggerConfig::mutable_start_trigger_config() {
  set_has_start_trigger_config();
  if (start_trigger_config_ == NULL) start_trigger_config_ = new ::Impinj::STP::StartTriggerConfig;
  return start_trigger_config_;
}
inline ::Impinj::STP::StartTriggerConfig* TriggerConfig::release_start_trigger_config() {
  clear_has_start_trigger_config();
  ::Impinj::STP::StartTriggerConfig* temp = start_trigger_config_;
  start_trigger_config_ = NULL;
  return temp;
}
inline void TriggerConfig::set_allocated_start_trigger_config(::Impinj::STP::StartTriggerConfig* start_trigger_config) {
  delete start_trigger_config_;
  start_trigger_config_ = start_trigger_config;
  if (start_trigger_config) {
    set_has_start_trigger_config();
  } else {
    clear_has_start_trigger_config();
  }
}

// optional .Impinj.STP.StopTriggerConfig stop_trigger_config = 2;
inline bool TriggerConfig::has_stop_trigger_config() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void TriggerConfig::set_has_stop_trigger_config() {
  _has_bits_[0] |= 0x00000002u;
}
inline void TriggerConfig::clear_has_stop_trigger_config() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void TriggerConfig::clear_stop_trigger_config() {
  if (stop_trigger_config_ != NULL) stop_trigger_config_->::Impinj::STP::StopTriggerConfig::Clear();
  clear_has_stop_trigger_config();
}
inline const ::Impinj::STP::StopTriggerConfig& TriggerConfig::stop_trigger_config() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return stop_trigger_config_ != NULL ? *stop_trigger_config_ : *default_instance().stop_trigger_config_;
#else
  return stop_trigger_config_ != NULL ? *stop_trigger_config_ : *default_instance_->stop_trigger_config_;
#endif
}
inline ::Impinj::STP::StopTriggerConfig* TriggerConfig::mutable_stop_trigger_config() {
  set_has_stop_trigger_config();
  if (stop_trigger_config_ == NULL) stop_trigger_config_ = new ::Impinj::STP::StopTriggerConfig;
  return stop_trigger_config_;
}
inline ::Impinj::STP::StopTriggerConfig* TriggerConfig::release_stop_trigger_config() {
  clear_has_stop_trigger_config();
  ::Impinj::STP::StopTriggerConfig* temp = stop_trigger_config_;
  stop_trigger_config_ = NULL;
  return temp;
}
inline void TriggerConfig::set_allocated_stop_trigger_config(::Impinj::STP::StopTriggerConfig* stop_trigger_config) {
  delete stop_trigger_config_;
  stop_trigger_config_ = stop_trigger_config;
  if (stop_trigger_config) {
    set_has_stop_trigger_config();
  } else {
    clear_has_stop_trigger_config();
  }
}

// -------------------------------------------------------------------

// StartTriggerConfig

// optional bool enable_gpi_start_trigger = 1 [default = true];
inline bool StartTriggerConfig::has_enable_gpi_start_trigger() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void StartTriggerConfig::set_has_enable_gpi_start_trigger() {
  _has_bits_[0] |= 0x00000001u;
}
inline void StartTriggerConfig::clear_has_enable_gpi_start_trigger() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void StartTriggerConfig::clear_enable_gpi_start_trigger() {
  enable_gpi_start_trigger_ = true;
  clear_has_enable_gpi_start_trigger();
}
inline bool StartTriggerConfig::enable_gpi_start_trigger() const {
  return enable_gpi_start_trigger_;
}
inline void StartTriggerConfig::set_enable_gpi_start_trigger(bool value) {
  set_has_enable_gpi_start_trigger();
  enable_gpi_start_trigger_ = value;
}

// -------------------------------------------------------------------

// StopTriggerConfig

// optional bool enable_gpi_stop_trigger = 1 [default = true];
inline bool StopTriggerConfig::has_enable_gpi_stop_trigger() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void StopTriggerConfig::set_has_enable_gpi_stop_trigger() {
  _has_bits_[0] |= 0x00000001u;
}
inline void StopTriggerConfig::clear_has_enable_gpi_stop_trigger() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void StopTriggerConfig::clear_enable_gpi_stop_trigger() {
  enable_gpi_stop_trigger_ = true;
  clear_has_enable_gpi_stop_trigger();
}
inline bool StopTriggerConfig::enable_gpi_stop_trigger() const {
  return enable_gpi_stop_trigger_;
}
inline void StopTriggerConfig::set_enable_gpi_stop_trigger(bool value) {
  set_has_enable_gpi_stop_trigger();
  enable_gpi_stop_trigger_ = value;
}

// optional uint32 timeout = 4 [default = 0];
inline bool StopTriggerConfig::has_timeout() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void StopTriggerConfig::set_has_timeout() {
  _has_bits_[0] |= 0x00000002u;
}
inline void StopTriggerConfig::clear_has_timeout() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void StopTriggerConfig::clear_timeout() {
  timeout_ = 0u;
  clear_has_timeout();
}
inline ::google::protobuf::uint32 StopTriggerConfig::timeout() const {
  return timeout_;
}
inline void StopTriggerConfig::set_timeout(::google::protobuf::uint32 value) {
  set_has_timeout();
  timeout_ = value;
}

// -------------------------------------------------------------------

// GPIConfig

// optional .Impinj.STP.GPIOSignalMode signaling_mode = 1 [default = GPIO_SIGNAL_MODE_COMBINED];
inline bool GPIConfig::has_signaling_mode() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GPIConfig::set_has_signaling_mode() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GPIConfig::clear_has_signaling_mode() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GPIConfig::clear_signaling_mode() {
  signaling_mode_ = 0;
  clear_has_signaling_mode();
}
inline ::Impinj::STP::GPIOSignalMode GPIConfig::signaling_mode() const {
  return static_cast< ::Impinj::STP::GPIOSignalMode >(signaling_mode_);
}
inline void GPIConfig::set_signaling_mode(::Impinj::STP::GPIOSignalMode value) {
  assert(::Impinj::STP::GPIOSignalMode_IsValid(value));
  set_has_signaling_mode();
  signaling_mode_ = value;
}

// optional .Impinj.STP.GPIOPolarity GPI1_polarity = 2 [default = GPIO_POLARITY_ACTIVE_LOW];
inline bool GPIConfig::has_gpi1_polarity() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void GPIConfig::set_has_gpi1_polarity() {
  _has_bits_[0] |= 0x00000002u;
}
inline void GPIConfig::clear_has_gpi1_polarity() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void GPIConfig::clear_gpi1_polarity() {
  gpi1_polarity_ = 0;
  clear_has_gpi1_polarity();
}
inline ::Impinj::STP::GPIOPolarity GPIConfig::gpi1_polarity() const {
  return static_cast< ::Impinj::STP::GPIOPolarity >(gpi1_polarity_);
}
inline void GPIConfig::set_gpi1_polarity(::Impinj::STP::GPIOPolarity value) {
  assert(::Impinj::STP::GPIOPolarity_IsValid(value));
  set_has_gpi1_polarity();
  gpi1_polarity_ = value;
}

// optional .Impinj.STP.GPIOPolarity GPI2_polarity = 3 [default = GPIO_POLARITY_ACTIVE_LOW];
inline bool GPIConfig::has_gpi2_polarity() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void GPIConfig::set_has_gpi2_polarity() {
  _has_bits_[0] |= 0x00000004u;
}
inline void GPIConfig::clear_has_gpi2_polarity() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void GPIConfig::clear_gpi2_polarity() {
  gpi2_polarity_ = 0;
  clear_has_gpi2_polarity();
}
inline ::Impinj::STP::GPIOPolarity GPIConfig::gpi2_polarity() const {
  return static_cast< ::Impinj::STP::GPIOPolarity >(gpi2_polarity_);
}
inline void GPIConfig::set_gpi2_polarity(::Impinj::STP::GPIOPolarity value) {
  assert(::Impinj::STP::GPIOPolarity_IsValid(value));
  set_has_gpi2_polarity();
  gpi2_polarity_ = value;
}

// optional .Impinj.STP.GPIOPolarity GPI3_polarity = 4 [default = GPIO_POLARITY_ACTIVE_LOW];
inline bool GPIConfig::has_gpi3_polarity() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void GPIConfig::set_has_gpi3_polarity() {
  _has_bits_[0] |= 0x00000008u;
}
inline void GPIConfig::clear_has_gpi3_polarity() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void GPIConfig::clear_gpi3_polarity() {
  gpi3_polarity_ = 0;
  clear_has_gpi3_polarity();
}
inline ::Impinj::STP::GPIOPolarity GPIConfig::gpi3_polarity() const {
  return static_cast< ::Impinj::STP::GPIOPolarity >(gpi3_polarity_);
}
inline void GPIConfig::set_gpi3_polarity(::Impinj::STP::GPIOPolarity value) {
  assert(::Impinj::STP::GPIOPolarity_IsValid(value));
  set_has_gpi3_polarity();
  gpi3_polarity_ = value;
}

// -------------------------------------------------------------------

// GPOConfig

// optional .Impinj.STP.GPIOSignalMode signaling_mode = 1 [default = GPIO_SIGNAL_MODE_SEPARATE];
inline bool GPOConfig::has_signaling_mode() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GPOConfig::set_has_signaling_mode() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GPOConfig::clear_has_signaling_mode() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GPOConfig::clear_signaling_mode() {
  signaling_mode_ = 1;
  clear_has_signaling_mode();
}
inline ::Impinj::STP::GPIOSignalMode GPOConfig::signaling_mode() const {
  return static_cast< ::Impinj::STP::GPIOSignalMode >(signaling_mode_);
}
inline void GPOConfig::set_signaling_mode(::Impinj::STP::GPIOSignalMode value) {
  assert(::Impinj::STP::GPIOSignalMode_IsValid(value));
  set_has_signaling_mode();
  signaling_mode_ = value;
}

// optional .Impinj.STP.GPIOPolarity GPO1_polarity = 6 [default = GPIO_POLARITY_ACTIVE_LOW];
inline bool GPOConfig::has_gpo1_polarity() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void GPOConfig::set_has_gpo1_polarity() {
  _has_bits_[0] |= 0x00000002u;
}
inline void GPOConfig::clear_has_gpo1_polarity() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void GPOConfig::clear_gpo1_polarity() {
  gpo1_polarity_ = 0;
  clear_has_gpo1_polarity();
}
inline ::Impinj::STP::GPIOPolarity GPOConfig::gpo1_polarity() const {
  return static_cast< ::Impinj::STP::GPIOPolarity >(gpo1_polarity_);
}
inline void GPOConfig::set_gpo1_polarity(::Impinj::STP::GPIOPolarity value) {
  assert(::Impinj::STP::GPIOPolarity_IsValid(value));
  set_has_gpo1_polarity();
  gpo1_polarity_ = value;
}

// optional .Impinj.STP.GPIOPolarity GPO2_polarity = 2 [default = GPIO_POLARITY_ACTIVE_LOW];
inline bool GPOConfig::has_gpo2_polarity() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void GPOConfig::set_has_gpo2_polarity() {
  _has_bits_[0] |= 0x00000004u;
}
inline void GPOConfig::clear_has_gpo2_polarity() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void GPOConfig::clear_gpo2_polarity() {
  gpo2_polarity_ = 0;
  clear_has_gpo2_polarity();
}
inline ::Impinj::STP::GPIOPolarity GPOConfig::gpo2_polarity() const {
  return static_cast< ::Impinj::STP::GPIOPolarity >(gpo2_polarity_);
}
inline void GPOConfig::set_gpo2_polarity(::Impinj::STP::GPIOPolarity value) {
  assert(::Impinj::STP::GPIOPolarity_IsValid(value));
  set_has_gpo2_polarity();
  gpo2_polarity_ = value;
}

// optional .Impinj.STP.GPIOPolarity GPO3_polarity = 3 [default = GPIO_POLARITY_ACTIVE_LOW];
inline bool GPOConfig::has_gpo3_polarity() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void GPOConfig::set_has_gpo3_polarity() {
  _has_bits_[0] |= 0x00000008u;
}
inline void GPOConfig::clear_has_gpo3_polarity() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void GPOConfig::clear_gpo3_polarity() {
  gpo3_polarity_ = 0;
  clear_has_gpo3_polarity();
}
inline ::Impinj::STP::GPIOPolarity GPOConfig::gpo3_polarity() const {
  return static_cast< ::Impinj::STP::GPIOPolarity >(gpo3_polarity_);
}
inline void GPOConfig::set_gpo3_polarity(::Impinj::STP::GPIOPolarity value) {
  assert(::Impinj::STP::GPIOPolarity_IsValid(value));
  set_has_gpo3_polarity();
  gpo3_polarity_ = value;
}

// optional uint32 GPO_pulse_duration = 4 [default = 1];
inline bool GPOConfig::has_gpo_pulse_duration() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void GPOConfig::set_has_gpo_pulse_duration() {
  _has_bits_[0] |= 0x00000010u;
}
inline void GPOConfig::clear_has_gpo_pulse_duration() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void GPOConfig::clear_gpo_pulse_duration() {
  gpo_pulse_duration_ = 1u;
  clear_has_gpo_pulse_duration();
}
inline ::google::protobuf::uint32 GPOConfig::gpo_pulse_duration() const {
  return gpo_pulse_duration_;
}
inline void GPOConfig::set_gpo_pulse_duration(::google::protobuf::uint32 value) {
  set_has_gpo_pulse_duration();
  gpo_pulse_duration_ = value;
}

// optional bool enable_operation_result_gpo = 5 [default = true];
inline bool GPOConfig::has_enable_operation_result_gpo() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void GPOConfig::set_has_enable_operation_result_gpo() {
  _has_bits_[0] |= 0x00000020u;
}
inline void GPOConfig::clear_has_enable_operation_result_gpo() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void GPOConfig::clear_enable_operation_result_gpo() {
  enable_operation_result_gpo_ = true;
  clear_has_enable_operation_result_gpo();
}
inline bool GPOConfig::enable_operation_result_gpo() const {
  return enable_operation_result_gpo_;
}
inline void GPOConfig::set_enable_operation_result_gpo(bool value) {
  set_has_enable_operation_result_gpo();
  enable_operation_result_gpo_ = value;
}

// -------------------------------------------------------------------

// STPDevice

// required string hostname = 1;
inline bool STPDevice::has_hostname() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void STPDevice::set_has_hostname() {
  _has_bits_[0] |= 0x00000001u;
}
inline void STPDevice::clear_has_hostname() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void STPDevice::clear_hostname() {
  if (hostname_ != &::google::protobuf::internal::kEmptyString) {
    hostname_->clear();
  }
  clear_has_hostname();
}
inline const ::std::string& STPDevice::hostname() const {
  return *hostname_;
}
inline void STPDevice::set_hostname(const ::std::string& value) {
  set_has_hostname();
  if (hostname_ == &::google::protobuf::internal::kEmptyString) {
    hostname_ = new ::std::string;
  }
  hostname_->assign(value);
}
inline void STPDevice::set_hostname(const char* value) {
  set_has_hostname();
  if (hostname_ == &::google::protobuf::internal::kEmptyString) {
    hostname_ = new ::std::string;
  }
  hostname_->assign(value);
}
inline void STPDevice::set_hostname(const char* value, size_t size) {
  set_has_hostname();
  if (hostname_ == &::google::protobuf::internal::kEmptyString) {
    hostname_ = new ::std::string;
  }
  hostname_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* STPDevice::mutable_hostname() {
  set_has_hostname();
  if (hostname_ == &::google::protobuf::internal::kEmptyString) {
    hostname_ = new ::std::string;
  }
  return hostname_;
}
inline ::std::string* STPDevice::release_hostname() {
  clear_has_hostname();
  if (hostname_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = hostname_;
    hostname_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void STPDevice::set_allocated_hostname(::std::string* hostname) {
  if (hostname_ != &::google::protobuf::internal::kEmptyString) {
    delete hostname_;
  }
  if (hostname) {
    set_has_hostname();
    hostname_ = hostname;
  } else {
    clear_has_hostname();
    hostname_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// -------------------------------------------------------------------

// OperationResponsibility

// optional bytes EPC_memory_mask = 1 [default = "\377\377"];
inline bool OperationResponsibility::has_epc_memory_mask() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void OperationResponsibility::set_has_epc_memory_mask() {
  _has_bits_[0] |= 0x00000001u;
}
inline void OperationResponsibility::clear_has_epc_memory_mask() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void OperationResponsibility::clear_epc_memory_mask() {
  if (epc_memory_mask_ != _default_epc_memory_mask_) {
    epc_memory_mask_->assign(*_default_epc_memory_mask_);
  }
  clear_has_epc_memory_mask();
}
inline const ::std::string& OperationResponsibility::epc_memory_mask() const {
  return *epc_memory_mask_;
}
inline void OperationResponsibility::set_epc_memory_mask(const ::std::string& value) {
  set_has_epc_memory_mask();
  if (epc_memory_mask_ == _default_epc_memory_mask_) {
    epc_memory_mask_ = new ::std::string;
  }
  epc_memory_mask_->assign(value);
}
inline void OperationResponsibility::set_epc_memory_mask(const char* value) {
  set_has_epc_memory_mask();
  if (epc_memory_mask_ == _default_epc_memory_mask_) {
    epc_memory_mask_ = new ::std::string;
  }
  epc_memory_mask_->assign(value);
}
inline void OperationResponsibility::set_epc_memory_mask(const void* value, size_t size) {
  set_has_epc_memory_mask();
  if (epc_memory_mask_ == _default_epc_memory_mask_) {
    epc_memory_mask_ = new ::std::string;
  }
  epc_memory_mask_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* OperationResponsibility::mutable_epc_memory_mask() {
  set_has_epc_memory_mask();
  if (epc_memory_mask_ == _default_epc_memory_mask_) {
    epc_memory_mask_ = new ::std::string(*_default_epc_memory_mask_);
  }
  return epc_memory_mask_;
}
inline ::std::string* OperationResponsibility::release_epc_memory_mask() {
  clear_has_epc_memory_mask();
  if (epc_memory_mask_ == _default_epc_memory_mask_) {
    return NULL;
  } else {
    ::std::string* temp = epc_memory_mask_;
    epc_memory_mask_ = const_cast< ::std::string*>(_default_epc_memory_mask_);
    return temp;
  }
}
inline void OperationResponsibility::set_allocated_epc_memory_mask(::std::string* epc_memory_mask) {
  if (epc_memory_mask_ != _default_epc_memory_mask_) {
    delete epc_memory_mask_;
  }
  if (epc_memory_mask) {
    set_has_epc_memory_mask();
    epc_memory_mask_ = epc_memory_mask;
  } else {
    clear_has_epc_memory_mask();
    epc_memory_mask_ = const_cast< ::std::string*>(_default_epc_memory_mask_);
  }
}

// optional bool EPC_memory_pc_word = 2 [default = true];
inline bool OperationResponsibility::has_epc_memory_pc_word() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void OperationResponsibility::set_has_epc_memory_pc_word() {
  _has_bits_[0] |= 0x00000002u;
}
inline void OperationResponsibility::clear_has_epc_memory_pc_word() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void OperationResponsibility::clear_epc_memory_pc_word() {
  epc_memory_pc_word_ = true;
  clear_has_epc_memory_pc_word();
}
inline bool OperationResponsibility::epc_memory_pc_word() const {
  return epc_memory_pc_word_;
}
inline void OperationResponsibility::set_epc_memory_pc_word(bool value) {
  set_has_epc_memory_pc_word();
  epc_memory_pc_word_ = value;
}

// optional bool TID_config_word = 18 [default = true];
inline bool OperationResponsibility::has_tid_config_word() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void OperationResponsibility::set_has_tid_config_word() {
  _has_bits_[0] |= 0x00000004u;
}
inline void OperationResponsibility::clear_has_tid_config_word() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void OperationResponsibility::clear_tid_config_word() {
  tid_config_word_ = true;
  clear_has_tid_config_word();
}
inline bool OperationResponsibility::tid_config_word() const {
  return tid_config_word_;
}
inline void OperationResponsibility::set_tid_config_word(bool value) {
  set_has_tid_config_word();
  tid_config_word_ = value;
}

// optional bytes user_memory_mask = 3 [default = "\377\377\377\377\377\377\377\377"];
inline bool OperationResponsibility::has_user_memory_mask() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void OperationResponsibility::set_has_user_memory_mask() {
  _has_bits_[0] |= 0x00000008u;
}
inline void OperationResponsibility::clear_has_user_memory_mask() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void OperationResponsibility::clear_user_memory_mask() {
  if (user_memory_mask_ != _default_user_memory_mask_) {
    user_memory_mask_->assign(*_default_user_memory_mask_);
  }
  clear_has_user_memory_mask();
}
inline const ::std::string& OperationResponsibility::user_memory_mask() const {
  return *user_memory_mask_;
}
inline void OperationResponsibility::set_user_memory_mask(const ::std::string& value) {
  set_has_user_memory_mask();
  if (user_memory_mask_ == _default_user_memory_mask_) {
    user_memory_mask_ = new ::std::string;
  }
  user_memory_mask_->assign(value);
}
inline void OperationResponsibility::set_user_memory_mask(const char* value) {
  set_has_user_memory_mask();
  if (user_memory_mask_ == _default_user_memory_mask_) {
    user_memory_mask_ = new ::std::string;
  }
  user_memory_mask_->assign(value);
}
inline void OperationResponsibility::set_user_memory_mask(const void* value, size_t size) {
  set_has_user_memory_mask();
  if (user_memory_mask_ == _default_user_memory_mask_) {
    user_memory_mask_ = new ::std::string;
  }
  user_memory_mask_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* OperationResponsibility::mutable_user_memory_mask() {
  set_has_user_memory_mask();
  if (user_memory_mask_ == _default_user_memory_mask_) {
    user_memory_mask_ = new ::std::string(*_default_user_memory_mask_);
  }
  return user_memory_mask_;
}
inline ::std::string* OperationResponsibility::release_user_memory_mask() {
  clear_has_user_memory_mask();
  if (user_memory_mask_ == _default_user_memory_mask_) {
    return NULL;
  } else {
    ::std::string* temp = user_memory_mask_;
    user_memory_mask_ = const_cast< ::std::string*>(_default_user_memory_mask_);
    return temp;
  }
}
inline void OperationResponsibility::set_allocated_user_memory_mask(::std::string* user_memory_mask) {
  if (user_memory_mask_ != _default_user_memory_mask_) {
    delete user_memory_mask_;
  }
  if (user_memory_mask) {
    set_has_user_memory_mask();
    user_memory_mask_ = user_memory_mask;
  } else {
    clear_has_user_memory_mask();
    user_memory_mask_ = const_cast< ::std::string*>(_default_user_memory_mask_);
  }
}

// optional bool secure_password = 4 [default = true];
inline bool OperationResponsibility::has_secure_password() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void OperationResponsibility::set_has_secure_password() {
  _has_bits_[0] |= 0x00000010u;
}
inline void OperationResponsibility::clear_has_secure_password() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void OperationResponsibility::clear_secure_password() {
  secure_password_ = true;
  clear_has_secure_password();
}
inline bool OperationResponsibility::secure_password() const {
  return secure_password_;
}
inline void OperationResponsibility::set_secure_password(bool value) {
  set_has_secure_password();
  secure_password_ = value;
}

// optional bool access_password = 5 [default = true];
inline bool OperationResponsibility::has_access_password() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void OperationResponsibility::set_has_access_password() {
  _has_bits_[0] |= 0x00000020u;
}
inline void OperationResponsibility::clear_has_access_password() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void OperationResponsibility::clear_access_password() {
  access_password_ = true;
  clear_has_access_password();
}
inline bool OperationResponsibility::access_password() const {
  return access_password_;
}
inline void OperationResponsibility::set_access_password(bool value) {
  set_has_access_password();
  access_password_ = value;
}

// optional bool kill_password = 6 [default = true];
inline bool OperationResponsibility::has_kill_password() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void OperationResponsibility::set_has_kill_password() {
  _has_bits_[0] |= 0x00000040u;
}
inline void OperationResponsibility::clear_has_kill_password() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void OperationResponsibility::clear_kill_password() {
  kill_password_ = true;
  clear_has_kill_password();
}
inline bool OperationResponsibility::kill_password() const {
  return kill_password_;
}
inline void OperationResponsibility::set_kill_password(bool value) {
  set_has_kill_password();
  kill_password_ = value;
}

// optional bool lock_config = 7 [default = true];
inline bool OperationResponsibility::has_lock_config() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void OperationResponsibility::set_has_lock_config() {
  _has_bits_[0] |= 0x00000080u;
}
inline void OperationResponsibility::clear_has_lock_config() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void OperationResponsibility::clear_lock_config() {
  lock_config_ = true;
  clear_has_lock_config();
}
inline bool OperationResponsibility::lock_config() const {
  return lock_config_;
}
inline void OperationResponsibility::set_lock_config(bool value) {
  set_has_lock_config();
  lock_config_ = value;
}

// optional bool blockpermalock_config = 8 [default = true];
inline bool OperationResponsibility::has_blockpermalock_config() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void OperationResponsibility::set_has_blockpermalock_config() {
  _has_bits_[0] |= 0x00000100u;
}
inline void OperationResponsibility::clear_has_blockpermalock_config() {
  _has_bits_[0] &= ~0x00000100u;
}
inline void OperationResponsibility::clear_blockpermalock_config() {
  blockpermalock_config_ = true;
  clear_has_blockpermalock_config();
}
inline bool OperationResponsibility::blockpermalock_config() const {
  return blockpermalock_config_;
}
inline void OperationResponsibility::set_blockpermalock_config(bool value) {
  set_has_blockpermalock_config();
  blockpermalock_config_ = value;
}

// optional bool kill_tag = 10 [default = true];
inline bool OperationResponsibility::has_kill_tag() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void OperationResponsibility::set_has_kill_tag() {
  _has_bits_[0] |= 0x00000200u;
}
inline void OperationResponsibility::clear_has_kill_tag() {
  _has_bits_[0] &= ~0x00000200u;
}
inline void OperationResponsibility::clear_kill_tag() {
  kill_tag_ = true;
  clear_has_kill_tag();
}
inline bool OperationResponsibility::kill_tag() const {
  return kill_tag_;
}
inline void OperationResponsibility::set_kill_tag(bool value) {
  set_has_kill_tag();
  kill_tag_ = value;
}

// optional bool tag_specific_feature_config = 17 [default = true];
inline bool OperationResponsibility::has_tag_specific_feature_config() const {
  return (_has_bits_[0] & 0x00000400u) != 0;
}
inline void OperationResponsibility::set_has_tag_specific_feature_config() {
  _has_bits_[0] |= 0x00000400u;
}
inline void OperationResponsibility::clear_has_tag_specific_feature_config() {
  _has_bits_[0] &= ~0x00000400u;
}
inline void OperationResponsibility::clear_tag_specific_feature_config() {
  tag_specific_feature_config_ = true;
  clear_has_tag_specific_feature_config();
}
inline bool OperationResponsibility::tag_specific_feature_config() const {
  return tag_specific_feature_config_;
}
inline void OperationResponsibility::set_tag_specific_feature_config(bool value) {
  set_has_tag_specific_feature_config();
  tag_specific_feature_config_ = value;
}

// optional uint32 tags_in_view_count = 11 [default = 6];
inline bool OperationResponsibility::has_tags_in_view_count() const {
  return (_has_bits_[0] & 0x00000800u) != 0;
}
inline void OperationResponsibility::set_has_tags_in_view_count() {
  _has_bits_[0] |= 0x00000800u;
}
inline void OperationResponsibility::clear_has_tags_in_view_count() {
  _has_bits_[0] &= ~0x00000800u;
}
inline void OperationResponsibility::clear_tags_in_view_count() {
  tags_in_view_count_ = 6u;
  clear_has_tags_in_view_count();
}
inline ::google::protobuf::uint32 OperationResponsibility::tags_in_view_count() const {
  return tags_in_view_count_;
}
inline void OperationResponsibility::set_tags_in_view_count(::google::protobuf::uint32 value) {
  set_has_tags_in_view_count();
  tags_in_view_count_ = value;
}

// optional uint32 tags_in_pipeline_view_count = 12 [default = 0];
inline bool OperationResponsibility::has_tags_in_pipeline_view_count() const {
  return (_has_bits_[0] & 0x00001000u) != 0;
}
inline void OperationResponsibility::set_has_tags_in_pipeline_view_count() {
  _has_bits_[0] |= 0x00001000u;
}
inline void OperationResponsibility::clear_has_tags_in_pipeline_view_count() {
  _has_bits_[0] &= ~0x00001000u;
}
inline void OperationResponsibility::clear_tags_in_pipeline_view_count() {
  tags_in_pipeline_view_count_ = 0u;
  clear_has_tags_in_pipeline_view_count();
}
inline ::google::protobuf::uint32 OperationResponsibility::tags_in_pipeline_view_count() const {
  return tags_in_pipeline_view_count_;
}
inline void OperationResponsibility::set_tags_in_pipeline_view_count(::google::protobuf::uint32 value) {
  set_has_tags_in_pipeline_view_count();
  tags_in_pipeline_view_count_ = value;
}

// repeated .Impinj.STP.STPDevice downstream_pipeline_devices = 13;
inline int OperationResponsibility::downstream_pipeline_devices_size() const {
  return downstream_pipeline_devices_.size();
}
inline void OperationResponsibility::clear_downstream_pipeline_devices() {
  downstream_pipeline_devices_.Clear();
}
inline const ::Impinj::STP::STPDevice& OperationResponsibility::downstream_pipeline_devices(int index) const {
  return downstream_pipeline_devices_.Get(index);
}
inline ::Impinj::STP::STPDevice* OperationResponsibility::mutable_downstream_pipeline_devices(int index) {
  return downstream_pipeline_devices_.Mutable(index);
}
inline ::Impinj::STP::STPDevice* OperationResponsibility::add_downstream_pipeline_devices() {
  return downstream_pipeline_devices_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::Impinj::STP::STPDevice >&
OperationResponsibility::downstream_pipeline_devices() const {
  return downstream_pipeline_devices_;
}
inline ::google::protobuf::RepeatedPtrField< ::Impinj::STP::STPDevice >*
OperationResponsibility::mutable_downstream_pipeline_devices() {
  return &downstream_pipeline_devices_;
}

// optional .Impinj.STP.STPDevice device_of_record = 14;
inline bool OperationResponsibility::has_device_of_record() const {
  return (_has_bits_[0] & 0x00004000u) != 0;
}
inline void OperationResponsibility::set_has_device_of_record() {
  _has_bits_[0] |= 0x00004000u;
}
inline void OperationResponsibility::clear_has_device_of_record() {
  _has_bits_[0] &= ~0x00004000u;
}
inline void OperationResponsibility::clear_device_of_record() {
  if (device_of_record_ != NULL) device_of_record_->::Impinj::STP::STPDevice::Clear();
  clear_has_device_of_record();
}
inline const ::Impinj::STP::STPDevice& OperationResponsibility::device_of_record() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return device_of_record_ != NULL ? *device_of_record_ : *default_instance().device_of_record_;
#else
  return device_of_record_ != NULL ? *device_of_record_ : *default_instance_->device_of_record_;
#endif
}
inline ::Impinj::STP::STPDevice* OperationResponsibility::mutable_device_of_record() {
  set_has_device_of_record();
  if (device_of_record_ == NULL) device_of_record_ = new ::Impinj::STP::STPDevice;
  return device_of_record_;
}
inline ::Impinj::STP::STPDevice* OperationResponsibility::release_device_of_record() {
  clear_has_device_of_record();
  ::Impinj::STP::STPDevice* temp = device_of_record_;
  device_of_record_ = NULL;
  return temp;
}
inline void OperationResponsibility::set_allocated_device_of_record(::Impinj::STP::STPDevice* device_of_record) {
  delete device_of_record_;
  device_of_record_ = device_of_record;
  if (device_of_record) {
    set_has_device_of_record();
  } else {
    clear_has_device_of_record();
  }
}

// optional uint32 voyantic_tagsurance_test_results_cache_size = 15;
inline bool OperationResponsibility::has_voyantic_tagsurance_test_results_cache_size() const {
  return (_has_bits_[0] & 0x00008000u) != 0;
}
inline void OperationResponsibility::set_has_voyantic_tagsurance_test_results_cache_size() {
  _has_bits_[0] |= 0x00008000u;
}
inline void OperationResponsibility::clear_has_voyantic_tagsurance_test_results_cache_size() {
  _has_bits_[0] &= ~0x00008000u;
}
inline void OperationResponsibility::clear_voyantic_tagsurance_test_results_cache_size() {
  voyantic_tagsurance_test_results_cache_size_ = 0u;
  clear_has_voyantic_tagsurance_test_results_cache_size();
}
inline ::google::protobuf::uint32 OperationResponsibility::voyantic_tagsurance_test_results_cache_size() const {
  return voyantic_tagsurance_test_results_cache_size_;
}
inline void OperationResponsibility::set_voyantic_tagsurance_test_results_cache_size(::google::protobuf::uint32 value) {
  set_has_voyantic_tagsurance_test_results_cache_size();
  voyantic_tagsurance_test_results_cache_size_ = value;
}

// optional .Impinj.STP.VoidTagResponsibility void_tag_responsibility = 16;
inline bool OperationResponsibility::has_void_tag_responsibility() const {
  return (_has_bits_[0] & 0x00010000u) != 0;
}
inline void OperationResponsibility::set_has_void_tag_responsibility() {
  _has_bits_[0] |= 0x00010000u;
}
inline void OperationResponsibility::clear_has_void_tag_responsibility() {
  _has_bits_[0] &= ~0x00010000u;
}
inline void OperationResponsibility::clear_void_tag_responsibility() {
  if (void_tag_responsibility_ != NULL) void_tag_responsibility_->::Impinj::STP::VoidTagResponsibility::Clear();
  clear_has_void_tag_responsibility();
}
inline const ::Impinj::STP::VoidTagResponsibility& OperationResponsibility::void_tag_responsibility() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return void_tag_responsibility_ != NULL ? *void_tag_responsibility_ : *default_instance().void_tag_responsibility_;
#else
  return void_tag_responsibility_ != NULL ? *void_tag_responsibility_ : *default_instance_->void_tag_responsibility_;
#endif
}
inline ::Impinj::STP::VoidTagResponsibility* OperationResponsibility::mutable_void_tag_responsibility() {
  set_has_void_tag_responsibility();
  if (void_tag_responsibility_ == NULL) void_tag_responsibility_ = new ::Impinj::STP::VoidTagResponsibility;
  return void_tag_responsibility_;
}
inline ::Impinj::STP::VoidTagResponsibility* OperationResponsibility::release_void_tag_responsibility() {
  clear_has_void_tag_responsibility();
  ::Impinj::STP::VoidTagResponsibility* temp = void_tag_responsibility_;
  void_tag_responsibility_ = NULL;
  return temp;
}
inline void OperationResponsibility::set_allocated_void_tag_responsibility(::Impinj::STP::VoidTagResponsibility* void_tag_responsibility) {
  delete void_tag_responsibility_;
  void_tag_responsibility_ = void_tag_responsibility;
  if (void_tag_responsibility) {
    set_has_void_tag_responsibility();
  } else {
    clear_has_void_tag_responsibility();
  }
}

// -------------------------------------------------------------------

// VoidTagResponsibility

// optional bool pc_word_to_zero = 1 [default = true];
inline bool VoidTagResponsibility::has_pc_word_to_zero() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void VoidTagResponsibility::set_has_pc_word_to_zero() {
  _has_bits_[0] |= 0x00000001u;
}
inline void VoidTagResponsibility::clear_has_pc_word_to_zero() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void VoidTagResponsibility::clear_pc_word_to_zero() {
  pc_word_to_zero_ = true;
  clear_has_pc_word_to_zero();
}
inline bool VoidTagResponsibility::pc_word_to_zero() const {
  return pc_word_to_zero_;
}
inline void VoidTagResponsibility::set_pc_word_to_zero(bool value) {
  set_has_pc_word_to_zero();
  pc_word_to_zero_ = value;
}

// optional bool first_epc_words = 2 [default = true];
inline bool VoidTagResponsibility::has_first_epc_words() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void VoidTagResponsibility::set_has_first_epc_words() {
  _has_bits_[0] |= 0x00000002u;
}
inline void VoidTagResponsibility::clear_has_first_epc_words() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void VoidTagResponsibility::clear_first_epc_words() {
  first_epc_words_ = true;
  clear_has_first_epc_words();
}
inline bool VoidTagResponsibility::first_epc_words() const {
  return first_epc_words_;
}
inline void VoidTagResponsibility::set_first_epc_words(bool value) {
  set_has_first_epc_words();
  first_epc_words_ = value;
}

// optional bool permalock = 3 [default = true];
inline bool VoidTagResponsibility::has_permalock() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void VoidTagResponsibility::set_has_permalock() {
  _has_bits_[0] |= 0x00000004u;
}
inline void VoidTagResponsibility::clear_has_permalock() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void VoidTagResponsibility::clear_permalock() {
  permalock_ = true;
  clear_has_permalock();
}
inline bool VoidTagResponsibility::permalock() const {
  return permalock_;
}
inline void VoidTagResponsibility::set_permalock(bool value) {
  set_has_permalock();
  permalock_ = value;
}

// optional bool kill = 4 [default = true];
inline bool VoidTagResponsibility::has_kill() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void VoidTagResponsibility::set_has_kill() {
  _has_bits_[0] |= 0x00000008u;
}
inline void VoidTagResponsibility::clear_has_kill() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void VoidTagResponsibility::clear_kill() {
  kill_ = true;
  clear_has_kill();
}
inline bool VoidTagResponsibility::kill() const {
  return kill_;
}
inline void VoidTagResponsibility::set_kill(bool value) {
  set_has_kill();
  kill_ = value;
}

// -------------------------------------------------------------------

// OperationSummaryReportConfig

// required bool enable_operation_summary_reports = 1 [default = true];
inline bool OperationSummaryReportConfig::has_enable_operation_summary_reports() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void OperationSummaryReportConfig::set_has_enable_operation_summary_reports() {
  _has_bits_[0] |= 0x00000001u;
}
inline void OperationSummaryReportConfig::clear_has_enable_operation_summary_reports() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void OperationSummaryReportConfig::clear_enable_operation_summary_reports() {
  enable_operation_summary_reports_ = true;
  clear_has_enable_operation_summary_reports();
}
inline bool OperationSummaryReportConfig::enable_operation_summary_reports() const {
  return enable_operation_summary_reports_;
}
inline void OperationSummaryReportConfig::set_enable_operation_summary_reports(bool value) {
  set_has_enable_operation_summary_reports();
  enable_operation_summary_reports_ = value;
}

// -------------------------------------------------------------------

// TagOperationReportConfig

// required bool enable_tag_operation_reports = 1 [default = true];
inline bool TagOperationReportConfig::has_enable_tag_operation_reports() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TagOperationReportConfig::set_has_enable_tag_operation_reports() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TagOperationReportConfig::clear_has_enable_tag_operation_reports() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TagOperationReportConfig::clear_enable_tag_operation_reports() {
  enable_tag_operation_reports_ = true;
  clear_has_enable_tag_operation_reports();
}
inline bool TagOperationReportConfig::enable_tag_operation_reports() const {
  return enable_tag_operation_reports_;
}
inline void TagOperationReportConfig::set_enable_tag_operation_reports(bool value) {
  set_has_enable_tag_operation_reports();
  enable_tag_operation_reports_ = value;
}

// optional bool enable_tag_operation_retry_reports = 2 [default = false];
inline bool TagOperationReportConfig::has_enable_tag_operation_retry_reports() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void TagOperationReportConfig::set_has_enable_tag_operation_retry_reports() {
  _has_bits_[0] |= 0x00000002u;
}
inline void TagOperationReportConfig::clear_has_enable_tag_operation_retry_reports() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void TagOperationReportConfig::clear_enable_tag_operation_retry_reports() {
  enable_tag_operation_retry_reports_ = false;
  clear_has_enable_tag_operation_retry_reports();
}
inline bool TagOperationReportConfig::enable_tag_operation_retry_reports() const {
  return enable_tag_operation_retry_reports_;
}
inline void TagOperationReportConfig::set_enable_tag_operation_retry_reports(bool value) {
  set_has_enable_tag_operation_retry_reports();
  enable_tag_operation_retry_reports_ = value;
}

// optional .Impinj.STP.TagOperationReportTrigger tag_operation_report_trigger = 3 [default = TAG_OPERATION_REPORT_TRIGGER_IMMEDIATE];
inline bool TagOperationReportConfig::has_tag_operation_report_trigger() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void TagOperationReportConfig::set_has_tag_operation_report_trigger() {
  _has_bits_[0] |= 0x00000004u;
}
inline void TagOperationReportConfig::clear_has_tag_operation_report_trigger() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void TagOperationReportConfig::clear_tag_operation_report_trigger() {
  tag_operation_report_trigger_ = 1;
  clear_has_tag_operation_report_trigger();
}
inline ::Impinj::STP::TagOperationReportTrigger TagOperationReportConfig::tag_operation_report_trigger() const {
  return static_cast< ::Impinj::STP::TagOperationReportTrigger >(tag_operation_report_trigger_);
}
inline void TagOperationReportConfig::set_tag_operation_report_trigger(::Impinj::STP::TagOperationReportTrigger value) {
  assert(::Impinj::STP::TagOperationReportTrigger_IsValid(value));
  set_has_tag_operation_report_trigger();
  tag_operation_report_trigger_ = value;
}

// optional bool enable_reporting_over_serial_port = 4 [default = false];
inline bool TagOperationReportConfig::has_enable_reporting_over_serial_port() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void TagOperationReportConfig::set_has_enable_reporting_over_serial_port() {
  _has_bits_[0] |= 0x00000008u;
}
inline void TagOperationReportConfig::clear_has_enable_reporting_over_serial_port() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void TagOperationReportConfig::clear_enable_reporting_over_serial_port() {
  enable_reporting_over_serial_port_ = false;
  clear_has_enable_reporting_over_serial_port();
}
inline bool TagOperationReportConfig::enable_reporting_over_serial_port() const {
  return enable_reporting_over_serial_port_;
}
inline void TagOperationReportConfig::set_enable_reporting_over_serial_port(bool value) {
  set_has_enable_reporting_over_serial_port();
  enable_reporting_over_serial_port_ = value;
}

// optional bool send_serial_report_after_GPO_deassert = 5 [default = false];
inline bool TagOperationReportConfig::has_send_serial_report_after_gpo_deassert() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void TagOperationReportConfig::set_has_send_serial_report_after_gpo_deassert() {
  _has_bits_[0] |= 0x00000010u;
}
inline void TagOperationReportConfig::clear_has_send_serial_report_after_gpo_deassert() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void TagOperationReportConfig::clear_send_serial_report_after_gpo_deassert() {
  send_serial_report_after_gpo_deassert_ = false;
  clear_has_send_serial_report_after_gpo_deassert();
}
inline bool TagOperationReportConfig::send_serial_report_after_gpo_deassert() const {
  return send_serial_report_after_gpo_deassert_;
}
inline void TagOperationReportConfig::set_send_serial_report_after_gpo_deassert(bool value) {
  set_has_send_serial_report_after_gpo_deassert();
  send_serial_report_after_gpo_deassert_ = value;
}

// optional bool enable_epc_in_serial_report = 6 [default = false];
inline bool TagOperationReportConfig::has_enable_epc_in_serial_report() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void TagOperationReportConfig::set_has_enable_epc_in_serial_report() {
  _has_bits_[0] |= 0x00000020u;
}
inline void TagOperationReportConfig::clear_has_enable_epc_in_serial_report() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void TagOperationReportConfig::clear_enable_epc_in_serial_report() {
  enable_epc_in_serial_report_ = false;
  clear_has_enable_epc_in_serial_report();
}
inline bool TagOperationReportConfig::enable_epc_in_serial_report() const {
  return enable_epc_in_serial_report_;
}
inline void TagOperationReportConfig::set_enable_epc_in_serial_report(bool value) {
  set_has_enable_epc_in_serial_report();
  enable_epc_in_serial_report_ = value;
}

// optional bool enable_tag_operation_pass_already_done_reports = 7 [default = false];
inline bool TagOperationReportConfig::has_enable_tag_operation_pass_already_done_reports() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void TagOperationReportConfig::set_has_enable_tag_operation_pass_already_done_reports() {
  _has_bits_[0] |= 0x00000040u;
}
inline void TagOperationReportConfig::clear_has_enable_tag_operation_pass_already_done_reports() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void TagOperationReportConfig::clear_enable_tag_operation_pass_already_done_reports() {
  enable_tag_operation_pass_already_done_reports_ = false;
  clear_has_enable_tag_operation_pass_already_done_reports();
}
inline bool TagOperationReportConfig::enable_tag_operation_pass_already_done_reports() const {
  return enable_tag_operation_pass_already_done_reports_;
}
inline void TagOperationReportConfig::set_enable_tag_operation_pass_already_done_reports(bool value) {
  set_has_enable_tag_operation_pass_already_done_reports();
  enable_tag_operation_pass_already_done_reports_ = value;
}

// -------------------------------------------------------------------

// ReportConfig

// optional .Impinj.STP.DeviceEventConfig device_event_config = 1;
inline bool ReportConfig::has_device_event_config() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ReportConfig::set_has_device_event_config() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ReportConfig::clear_has_device_event_config() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ReportConfig::clear_device_event_config() {
  if (device_event_config_ != NULL) device_event_config_->::Impinj::STP::DeviceEventConfig::Clear();
  clear_has_device_event_config();
}
inline const ::Impinj::STP::DeviceEventConfig& ReportConfig::device_event_config() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return device_event_config_ != NULL ? *device_event_config_ : *default_instance().device_event_config_;
#else
  return device_event_config_ != NULL ? *device_event_config_ : *default_instance_->device_event_config_;
#endif
}
inline ::Impinj::STP::DeviceEventConfig* ReportConfig::mutable_device_event_config() {
  set_has_device_event_config();
  if (device_event_config_ == NULL) device_event_config_ = new ::Impinj::STP::DeviceEventConfig;
  return device_event_config_;
}
inline ::Impinj::STP::DeviceEventConfig* ReportConfig::release_device_event_config() {
  clear_has_device_event_config();
  ::Impinj::STP::DeviceEventConfig* temp = device_event_config_;
  device_event_config_ = NULL;
  return temp;
}
inline void ReportConfig::set_allocated_device_event_config(::Impinj::STP::DeviceEventConfig* device_event_config) {
  delete device_event_config_;
  device_event_config_ = device_event_config;
  if (device_event_config) {
    set_has_device_event_config();
  } else {
    clear_has_device_event_config();
  }
}

// optional .Impinj.STP.OperationSummaryReportConfig operation_summary_report_config = 2;
inline bool ReportConfig::has_operation_summary_report_config() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ReportConfig::set_has_operation_summary_report_config() {
  _has_bits_[0] |= 0x00000002u;
}
inline void ReportConfig::clear_has_operation_summary_report_config() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void ReportConfig::clear_operation_summary_report_config() {
  if (operation_summary_report_config_ != NULL) operation_summary_report_config_->::Impinj::STP::OperationSummaryReportConfig::Clear();
  clear_has_operation_summary_report_config();
}
inline const ::Impinj::STP::OperationSummaryReportConfig& ReportConfig::operation_summary_report_config() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return operation_summary_report_config_ != NULL ? *operation_summary_report_config_ : *default_instance().operation_summary_report_config_;
#else
  return operation_summary_report_config_ != NULL ? *operation_summary_report_config_ : *default_instance_->operation_summary_report_config_;
#endif
}
inline ::Impinj::STP::OperationSummaryReportConfig* ReportConfig::mutable_operation_summary_report_config() {
  set_has_operation_summary_report_config();
  if (operation_summary_report_config_ == NULL) operation_summary_report_config_ = new ::Impinj::STP::OperationSummaryReportConfig;
  return operation_summary_report_config_;
}
inline ::Impinj::STP::OperationSummaryReportConfig* ReportConfig::release_operation_summary_report_config() {
  clear_has_operation_summary_report_config();
  ::Impinj::STP::OperationSummaryReportConfig* temp = operation_summary_report_config_;
  operation_summary_report_config_ = NULL;
  return temp;
}
inline void ReportConfig::set_allocated_operation_summary_report_config(::Impinj::STP::OperationSummaryReportConfig* operation_summary_report_config) {
  delete operation_summary_report_config_;
  operation_summary_report_config_ = operation_summary_report_config;
  if (operation_summary_report_config) {
    set_has_operation_summary_report_config();
  } else {
    clear_has_operation_summary_report_config();
  }
}

// optional .Impinj.STP.TagOperationReportConfig tag_operation_report_config = 3;
inline bool ReportConfig::has_tag_operation_report_config() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ReportConfig::set_has_tag_operation_report_config() {
  _has_bits_[0] |= 0x00000004u;
}
inline void ReportConfig::clear_has_tag_operation_report_config() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void ReportConfig::clear_tag_operation_report_config() {
  if (tag_operation_report_config_ != NULL) tag_operation_report_config_->::Impinj::STP::TagOperationReportConfig::Clear();
  clear_has_tag_operation_report_config();
}
inline const ::Impinj::STP::TagOperationReportConfig& ReportConfig::tag_operation_report_config() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return tag_operation_report_config_ != NULL ? *tag_operation_report_config_ : *default_instance().tag_operation_report_config_;
#else
  return tag_operation_report_config_ != NULL ? *tag_operation_report_config_ : *default_instance_->tag_operation_report_config_;
#endif
}
inline ::Impinj::STP::TagOperationReportConfig* ReportConfig::mutable_tag_operation_report_config() {
  set_has_tag_operation_report_config();
  if (tag_operation_report_config_ == NULL) tag_operation_report_config_ = new ::Impinj::STP::TagOperationReportConfig;
  return tag_operation_report_config_;
}
inline ::Impinj::STP::TagOperationReportConfig* ReportConfig::release_tag_operation_report_config() {
  clear_has_tag_operation_report_config();
  ::Impinj::STP::TagOperationReportConfig* temp = tag_operation_report_config_;
  tag_operation_report_config_ = NULL;
  return temp;
}
inline void ReportConfig::set_allocated_tag_operation_report_config(::Impinj::STP::TagOperationReportConfig* tag_operation_report_config) {
  delete tag_operation_report_config_;
  tag_operation_report_config_ = tag_operation_report_config;
  if (tag_operation_report_config) {
    set_has_tag_operation_report_config();
  } else {
    clear_has_tag_operation_report_config();
  }
}

// -------------------------------------------------------------------

// AntennaConfig

// required uint32 antenna_ID = 1;
inline bool AntennaConfig::has_antenna_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void AntennaConfig::set_has_antenna_id() {
  _has_bits_[0] |= 0x00000001u;
}
inline void AntennaConfig::clear_has_antenna_id() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void AntennaConfig::clear_antenna_id() {
  antenna_id_ = 0u;
  clear_has_antenna_id();
}
inline ::google::protobuf::uint32 AntennaConfig::antenna_id() const {
  return antenna_id_;
}
inline void AntennaConfig::set_antenna_id(::google::protobuf::uint32 value) {
  set_has_antenna_id();
  antenna_id_ = value;
}

// optional .Impinj.STP.Gen2Mode gen2_mode = 4 [default = GEN2_MODE_MAX_THROUGHPUT];
inline bool AntennaConfig::has_gen2_mode() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void AntennaConfig::set_has_gen2_mode() {
  _has_bits_[0] |= 0x00000002u;
}
inline void AntennaConfig::clear_has_gen2_mode() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void AntennaConfig::clear_gen2_mode() {
  gen2_mode_ = 0;
  clear_has_gen2_mode();
}
inline ::Impinj::STP::Gen2Mode AntennaConfig::gen2_mode() const {
  return static_cast< ::Impinj::STP::Gen2Mode >(gen2_mode_);
}
inline void AntennaConfig::set_gen2_mode(::Impinj::STP::Gen2Mode value) {
  assert(::Impinj::STP::Gen2Mode_IsValid(value));
  set_has_gen2_mode();
  gen2_mode_ = value;
}

// optional .Impinj.STP.InventorySearchMode inventory_search_mode = 5 [default = INVENTORY_SEARCH_MODE_SINGLE_TARGET_A_TO_B_MONZA_TAGFOCUS];
inline bool AntennaConfig::has_inventory_search_mode() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void AntennaConfig::set_has_inventory_search_mode() {
  _has_bits_[0] |= 0x00000004u;
}
inline void AntennaConfig::clear_has_inventory_search_mode() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void AntennaConfig::clear_inventory_search_mode() {
  inventory_search_mode_ = 4;
  clear_has_inventory_search_mode();
}
inline ::Impinj::STP::InventorySearchMode AntennaConfig::inventory_search_mode() const {
  return static_cast< ::Impinj::STP::InventorySearchMode >(inventory_search_mode_);
}
inline void AntennaConfig::set_inventory_search_mode(::Impinj::STP::InventorySearchMode value) {
  assert(::Impinj::STP::InventorySearchMode_IsValid(value));
  set_has_inventory_search_mode();
  inventory_search_mode_ = value;
}

// optional .Impinj.STP.Gen2Session gen2_session = 6 [default = GEN2_SESSION_1];
inline bool AntennaConfig::has_gen2_session() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void AntennaConfig::set_has_gen2_session() {
  _has_bits_[0] |= 0x00000008u;
}
inline void AntennaConfig::clear_has_gen2_session() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void AntennaConfig::clear_gen2_session() {
  gen2_session_ = 1;
  clear_has_gen2_session();
}
inline ::Impinj::STP::Gen2Session AntennaConfig::gen2_session() const {
  return static_cast< ::Impinj::STP::Gen2Session >(gen2_session_);
}
inline void AntennaConfig::set_gen2_session(::Impinj::STP::Gen2Session value) {
  assert(::Impinj::STP::Gen2Session_IsValid(value));
  set_has_gen2_session();
  gen2_session_ = value;
}

// optional sint32 transmit_power = 7 [default = 3000];
inline bool AntennaConfig::has_transmit_power() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void AntennaConfig::set_has_transmit_power() {
  _has_bits_[0] |= 0x00000010u;
}
inline void AntennaConfig::clear_has_transmit_power() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void AntennaConfig::clear_transmit_power() {
  transmit_power_ = 3000;
  clear_has_transmit_power();
}
inline ::google::protobuf::int32 AntennaConfig::transmit_power() const {
  return transmit_power_;
}
inline void AntennaConfig::set_transmit_power(::google::protobuf::int32 value) {
  set_has_transmit_power();
  transmit_power_ = value;
}

// optional sint32 receive_sensitivity = 8;
inline bool AntennaConfig::has_receive_sensitivity() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void AntennaConfig::set_has_receive_sensitivity() {
  _has_bits_[0] |= 0x00000020u;
}
inline void AntennaConfig::clear_has_receive_sensitivity() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void AntennaConfig::clear_receive_sensitivity() {
  receive_sensitivity_ = 0;
  clear_has_receive_sensitivity();
}
inline ::google::protobuf::int32 AntennaConfig::receive_sensitivity() const {
  return receive_sensitivity_;
}
inline void AntennaConfig::set_receive_sensitivity(::google::protobuf::int32 value) {
  set_has_receive_sensitivity();
  receive_sensitivity_ = value;
}

// optional uint32 tag_population_estimate = 10 [default = 32];
inline bool AntennaConfig::has_tag_population_estimate() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void AntennaConfig::set_has_tag_population_estimate() {
  _has_bits_[0] |= 0x00000040u;
}
inline void AntennaConfig::clear_has_tag_population_estimate() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void AntennaConfig::clear_tag_population_estimate() {
  tag_population_estimate_ = 32u;
  clear_has_tag_population_estimate();
}
inline ::google::protobuf::uint32 AntennaConfig::tag_population_estimate() const {
  return tag_population_estimate_;
}
inline void AntennaConfig::set_tag_population_estimate(::google::protobuf::uint32 value) {
  set_has_tag_population_estimate();
  tag_population_estimate_ = value;
}

// optional uint32 minimum_dwell_time = 11 [default = 0];
inline bool AntennaConfig::has_minimum_dwell_time() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void AntennaConfig::set_has_minimum_dwell_time() {
  _has_bits_[0] |= 0x00000080u;
}
inline void AntennaConfig::clear_has_minimum_dwell_time() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void AntennaConfig::clear_minimum_dwell_time() {
  minimum_dwell_time_ = 0u;
  clear_has_minimum_dwell_time();
}
inline ::google::protobuf::uint32 AntennaConfig::minimum_dwell_time() const {
  return minimum_dwell_time_;
}
inline void AntennaConfig::set_minimum_dwell_time(::google::protobuf::uint32 value) {
  set_has_minimum_dwell_time();
  minimum_dwell_time_ = value;
}

// optional uint32 maximum_dwell_time = 12 [default = 0];
inline bool AntennaConfig::has_maximum_dwell_time() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void AntennaConfig::set_has_maximum_dwell_time() {
  _has_bits_[0] |= 0x00000100u;
}
inline void AntennaConfig::clear_has_maximum_dwell_time() {
  _has_bits_[0] &= ~0x00000100u;
}
inline void AntennaConfig::clear_maximum_dwell_time() {
  maximum_dwell_time_ = 0u;
  clear_has_maximum_dwell_time();
}
inline ::google::protobuf::uint32 AntennaConfig::maximum_dwell_time() const {
  return maximum_dwell_time_;
}
inline void AntennaConfig::set_maximum_dwell_time(::google::protobuf::uint32 value) {
  set_has_maximum_dwell_time();
  maximum_dwell_time_ = value;
}

// optional bool enable_query_for_q_increase = 13 [default = false];
inline bool AntennaConfig::has_enable_query_for_q_increase() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void AntennaConfig::set_has_enable_query_for_q_increase() {
  _has_bits_[0] |= 0x00000200u;
}
inline void AntennaConfig::clear_has_enable_query_for_q_increase() {
  _has_bits_[0] &= ~0x00000200u;
}
inline void AntennaConfig::clear_enable_query_for_q_increase() {
  enable_query_for_q_increase_ = false;
  clear_has_enable_query_for_q_increase();
}
inline bool AntennaConfig::enable_query_for_q_increase() const {
  return enable_query_for_q_increase_;
}
inline void AntennaConfig::set_enable_query_for_q_increase(bool value) {
  set_has_enable_query_for_q_increase();
  enable_query_for_q_increase_ = value;
}

// optional bool enable_query_for_q_decrease = 14 [default = false];
inline bool AntennaConfig::has_enable_query_for_q_decrease() const {
  return (_has_bits_[0] & 0x00000400u) != 0;
}
inline void AntennaConfig::set_has_enable_query_for_q_decrease() {
  _has_bits_[0] |= 0x00000400u;
}
inline void AntennaConfig::clear_has_enable_query_for_q_decrease() {
  _has_bits_[0] &= ~0x00000400u;
}
inline void AntennaConfig::clear_enable_query_for_q_decrease() {
  enable_query_for_q_decrease_ = false;
  clear_has_enable_query_for_q_decrease();
}
inline bool AntennaConfig::enable_query_for_q_decrease() const {
  return enable_query_for_q_decrease_;
}
inline void AntennaConfig::set_enable_query_for_q_decrease(bool value) {
  set_has_enable_query_for_q_decrease();
  enable_query_for_q_decrease_ = value;
}

// optional bool enable_query_at_u_cycle_end = 15 [default = false];
inline bool AntennaConfig::has_enable_query_at_u_cycle_end() const {
  return (_has_bits_[0] & 0x00000800u) != 0;
}
inline void AntennaConfig::set_has_enable_query_at_u_cycle_end() {
  _has_bits_[0] |= 0x00000800u;
}
inline void AntennaConfig::clear_has_enable_query_at_u_cycle_end() {
  _has_bits_[0] &= ~0x00000800u;
}
inline void AntennaConfig::clear_enable_query_at_u_cycle_end() {
  enable_query_at_u_cycle_end_ = false;
  clear_has_enable_query_at_u_cycle_end();
}
inline bool AntennaConfig::enable_query_at_u_cycle_end() const {
  return enable_query_at_u_cycle_end_;
}
inline void AntennaConfig::set_enable_query_at_u_cycle_end(bool value) {
  set_has_enable_query_at_u_cycle_end();
  enable_query_at_u_cycle_end_ = value;
}

// optional bool enable_adaptive_tag_population_estimate = 16 [default = false];
inline bool AntennaConfig::has_enable_adaptive_tag_population_estimate() const {
  return (_has_bits_[0] & 0x00001000u) != 0;
}
inline void AntennaConfig::set_has_enable_adaptive_tag_population_estimate() {
  _has_bits_[0] |= 0x00001000u;
}
inline void AntennaConfig::clear_has_enable_adaptive_tag_population_estimate() {
  _has_bits_[0] &= ~0x00001000u;
}
inline void AntennaConfig::clear_enable_adaptive_tag_population_estimate() {
  enable_adaptive_tag_population_estimate_ = false;
  clear_has_enable_adaptive_tag_population_estimate();
}
inline bool AntennaConfig::enable_adaptive_tag_population_estimate() const {
  return enable_adaptive_tag_population_estimate_;
}
inline void AntennaConfig::set_enable_adaptive_tag_population_estimate(bool value) {
  set_has_enable_adaptive_tag_population_estimate();
  enable_adaptive_tag_population_estimate_ = value;
}

// -------------------------------------------------------------------

// AntennasConfig

// repeated .Impinj.STP.AntennaConfig antenna_config = 1;
inline int AntennasConfig::antenna_config_size() const {
  return antenna_config_.size();
}
inline void AntennasConfig::clear_antenna_config() {
  antenna_config_.Clear();
}
inline const ::Impinj::STP::AntennaConfig& AntennasConfig::antenna_config(int index) const {
  return antenna_config_.Get(index);
}
inline ::Impinj::STP::AntennaConfig* AntennasConfig::mutable_antenna_config(int index) {
  return antenna_config_.Mutable(index);
}
inline ::Impinj::STP::AntennaConfig* AntennasConfig::add_antenna_config() {
  return antenna_config_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::Impinj::STP::AntennaConfig >&
AntennasConfig::antenna_config() const {
  return antenna_config_;
}
inline ::google::protobuf::RepeatedPtrField< ::Impinj::STP::AntennaConfig >*
AntennasConfig::mutable_antenna_config() {
  return &antenna_config_;
}

// -------------------------------------------------------------------

// InventoryJob

// optional uint32 job_id = 1 [default = 1];
inline bool InventoryJob::has_job_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void InventoryJob::set_has_job_id() {
  _has_bits_[0] |= 0x00000001u;
}
inline void InventoryJob::clear_has_job_id() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void InventoryJob::clear_job_id() {
  job_id_ = 1u;
  clear_has_job_id();
}
inline ::google::protobuf::uint32 InventoryJob::job_id() const {
  return job_id_;
}
inline void InventoryJob::set_job_id(::google::protobuf::uint32 value) {
  set_has_job_id();
  job_id_ = value;
}

// optional .Impinj.STP.UserMemory user_memory = 2;
inline bool InventoryJob::has_user_memory() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void InventoryJob::set_has_user_memory() {
  _has_bits_[0] |= 0x00000002u;
}
inline void InventoryJob::clear_has_user_memory() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void InventoryJob::clear_user_memory() {
  if (user_memory_ != NULL) user_memory_->::Impinj::STP::UserMemory::Clear();
  clear_has_user_memory();
}
inline const ::Impinj::STP::UserMemory& InventoryJob::user_memory() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return user_memory_ != NULL ? *user_memory_ : *default_instance().user_memory_;
#else
  return user_memory_ != NULL ? *user_memory_ : *default_instance_->user_memory_;
#endif
}
inline ::Impinj::STP::UserMemory* InventoryJob::mutable_user_memory() {
  set_has_user_memory();
  if (user_memory_ == NULL) user_memory_ = new ::Impinj::STP::UserMemory;
  return user_memory_;
}
inline ::Impinj::STP::UserMemory* InventoryJob::release_user_memory() {
  clear_has_user_memory();
  ::Impinj::STP::UserMemory* temp = user_memory_;
  user_memory_ = NULL;
  return temp;
}
inline void InventoryJob::set_allocated_user_memory(::Impinj::STP::UserMemory* user_memory) {
  delete user_memory_;
  user_memory_ = user_memory;
  if (user_memory) {
    set_has_user_memory();
  } else {
    clear_has_user_memory();
  }
}

// -------------------------------------------------------------------

// CartonContentsJob

// optional uint32 job_id = 1 [default = 1];
inline bool CartonContentsJob::has_job_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CartonContentsJob::set_has_job_id() {
  _has_bits_[0] |= 0x00000001u;
}
inline void CartonContentsJob::clear_has_job_id() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void CartonContentsJob::clear_job_id() {
  job_id_ = 1u;
  clear_has_job_id();
}
inline ::google::protobuf::uint32 CartonContentsJob::job_id() const {
  return job_id_;
}
inline void CartonContentsJob::set_job_id(::google::protobuf::uint32 value) {
  set_has_job_id();
  job_id_ = value;
}

// optional uint32 enter_trigger_offset = 6;
inline bool CartonContentsJob::has_enter_trigger_offset() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void CartonContentsJob::set_has_enter_trigger_offset() {
  _has_bits_[0] |= 0x00000002u;
}
inline void CartonContentsJob::clear_has_enter_trigger_offset() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void CartonContentsJob::clear_enter_trigger_offset() {
  enter_trigger_offset_ = 0u;
  clear_has_enter_trigger_offset();
}
inline ::google::protobuf::uint32 CartonContentsJob::enter_trigger_offset() const {
  return enter_trigger_offset_;
}
inline void CartonContentsJob::set_enter_trigger_offset(::google::protobuf::uint32 value) {
  set_has_enter_trigger_offset();
  enter_trigger_offset_ = value;
}

// optional uint32 exit_trigger_offset = 7;
inline bool CartonContentsJob::has_exit_trigger_offset() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void CartonContentsJob::set_has_exit_trigger_offset() {
  _has_bits_[0] |= 0x00000004u;
}
inline void CartonContentsJob::clear_has_exit_trigger_offset() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void CartonContentsJob::clear_exit_trigger_offset() {
  exit_trigger_offset_ = 0u;
  clear_has_exit_trigger_offset();
}
inline ::google::protobuf::uint32 CartonContentsJob::exit_trigger_offset() const {
  return exit_trigger_offset_;
}
inline void CartonContentsJob::set_exit_trigger_offset(::google::protobuf::uint32 value) {
  set_has_exit_trigger_offset();
  exit_trigger_offset_ = value;
}

// optional uint32 carton_velocity = 4;
inline bool CartonContentsJob::has_carton_velocity() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void CartonContentsJob::set_has_carton_velocity() {
  _has_bits_[0] |= 0x00000008u;
}
inline void CartonContentsJob::clear_has_carton_velocity() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void CartonContentsJob::clear_carton_velocity() {
  carton_velocity_ = 0u;
  clear_has_carton_velocity();
}
inline ::google::protobuf::uint32 CartonContentsJob::carton_velocity() const {
  return carton_velocity_;
}
inline void CartonContentsJob::set_carton_velocity(::google::protobuf::uint32 value) {
  set_has_carton_velocity();
  carton_velocity_ = value;
}

// optional bool read_tid = 8 [default = true];
inline bool CartonContentsJob::has_read_tid() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void CartonContentsJob::set_has_read_tid() {
  _has_bits_[0] |= 0x00000010u;
}
inline void CartonContentsJob::clear_has_read_tid() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void CartonContentsJob::clear_read_tid() {
  read_tid_ = true;
  clear_has_read_tid();
}
inline bool CartonContentsJob::read_tid() const {
  return read_tid_;
}
inline void CartonContentsJob::set_read_tid(bool value) {
  set_has_read_tid();
  read_tid_ = value;
}

// optional uint32 carton_spacing = 5;
inline bool CartonContentsJob::has_carton_spacing() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void CartonContentsJob::set_has_carton_spacing() {
  _has_bits_[0] |= 0x00000020u;
}
inline void CartonContentsJob::clear_has_carton_spacing() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void CartonContentsJob::clear_carton_spacing() {
  carton_spacing_ = 0u;
  clear_has_carton_spacing();
}
inline ::google::protobuf::uint32 CartonContentsJob::carton_spacing() const {
  return carton_spacing_;
}
inline void CartonContentsJob::set_carton_spacing(::google::protobuf::uint32 value) {
  set_has_carton_spacing();
  carton_spacing_ = value;
}

// optional uint32 start_trigger_offset = 2;
inline bool CartonContentsJob::has_start_trigger_offset() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void CartonContentsJob::set_has_start_trigger_offset() {
  _has_bits_[0] |= 0x00000040u;
}
inline void CartonContentsJob::clear_has_start_trigger_offset() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void CartonContentsJob::clear_start_trigger_offset() {
  start_trigger_offset_ = 0u;
  clear_has_start_trigger_offset();
}
inline ::google::protobuf::uint32 CartonContentsJob::start_trigger_offset() const {
  return start_trigger_offset_;
}
inline void CartonContentsJob::set_start_trigger_offset(::google::protobuf::uint32 value) {
  set_has_start_trigger_offset();
  start_trigger_offset_ = value;
}

// optional uint32 stop_trigger_offset = 3;
inline bool CartonContentsJob::has_stop_trigger_offset() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void CartonContentsJob::set_has_stop_trigger_offset() {
  _has_bits_[0] |= 0x00000080u;
}
inline void CartonContentsJob::clear_has_stop_trigger_offset() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void CartonContentsJob::clear_stop_trigger_offset() {
  stop_trigger_offset_ = 0u;
  clear_has_stop_trigger_offset();
}
inline ::google::protobuf::uint32 CartonContentsJob::stop_trigger_offset() const {
  return stop_trigger_offset_;
}
inline void CartonContentsJob::set_stop_trigger_offset(::google::protobuf::uint32 value) {
  set_has_stop_trigger_offset();
  stop_trigger_offset_ = value;
}

// -------------------------------------------------------------------

// VoidTagConfig

// optional bool kill_tag = 1;
inline bool VoidTagConfig::has_kill_tag() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void VoidTagConfig::set_has_kill_tag() {
  _has_bits_[0] |= 0x00000001u;
}
inline void VoidTagConfig::clear_has_kill_tag() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void VoidTagConfig::clear_kill_tag() {
  kill_tag_ = false;
  clear_has_kill_tag();
}
inline bool VoidTagConfig::kill_tag() const {
  return kill_tag_;
}
inline void VoidTagConfig::set_kill_tag(bool value) {
  set_has_kill_tag();
  kill_tag_ = value;
}

// optional bool permalock_all_banks = 2;
inline bool VoidTagConfig::has_permalock_all_banks() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void VoidTagConfig::set_has_permalock_all_banks() {
  _has_bits_[0] |= 0x00000002u;
}
inline void VoidTagConfig::clear_has_permalock_all_banks() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void VoidTagConfig::clear_permalock_all_banks() {
  permalock_all_banks_ = false;
  clear_has_permalock_all_banks();
}
inline bool VoidTagConfig::permalock_all_banks() const {
  return permalock_all_banks_;
}
inline void VoidTagConfig::set_permalock_all_banks(bool value) {
  set_has_permalock_all_banks();
  permalock_all_banks_ = value;
}

// -------------------------------------------------------------------

// Filter

// optional bytes data = 1;
inline bool Filter::has_data() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Filter::set_has_data() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Filter::clear_has_data() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Filter::clear_data() {
  if (data_ != &::google::protobuf::internal::kEmptyString) {
    data_->clear();
  }
  clear_has_data();
}
inline const ::std::string& Filter::data() const {
  return *data_;
}
inline void Filter::set_data(const ::std::string& value) {
  set_has_data();
  if (data_ == &::google::protobuf::internal::kEmptyString) {
    data_ = new ::std::string;
  }
  data_->assign(value);
}
inline void Filter::set_data(const char* value) {
  set_has_data();
  if (data_ == &::google::protobuf::internal::kEmptyString) {
    data_ = new ::std::string;
  }
  data_->assign(value);
}
inline void Filter::set_data(const void* value, size_t size) {
  set_has_data();
  if (data_ == &::google::protobuf::internal::kEmptyString) {
    data_ = new ::std::string;
  }
  data_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Filter::mutable_data() {
  set_has_data();
  if (data_ == &::google::protobuf::internal::kEmptyString) {
    data_ = new ::std::string;
  }
  return data_;
}
inline ::std::string* Filter::release_data() {
  clear_has_data();
  if (data_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = data_;
    data_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void Filter::set_allocated_data(::std::string* data) {
  if (data_ != &::google::protobuf::internal::kEmptyString) {
    delete data_;
  }
  if (data) {
    set_has_data();
    data_ = data;
  } else {
    clear_has_data();
    data_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional bytes mask = 2;
inline bool Filter::has_mask() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void Filter::set_has_mask() {
  _has_bits_[0] |= 0x00000002u;
}
inline void Filter::clear_has_mask() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void Filter::clear_mask() {
  if (mask_ != &::google::protobuf::internal::kEmptyString) {
    mask_->clear();
  }
  clear_has_mask();
}
inline const ::std::string& Filter::mask() const {
  return *mask_;
}
inline void Filter::set_mask(const ::std::string& value) {
  set_has_mask();
  if (mask_ == &::google::protobuf::internal::kEmptyString) {
    mask_ = new ::std::string;
  }
  mask_->assign(value);
}
inline void Filter::set_mask(const char* value) {
  set_has_mask();
  if (mask_ == &::google::protobuf::internal::kEmptyString) {
    mask_ = new ::std::string;
  }
  mask_->assign(value);
}
inline void Filter::set_mask(const void* value, size_t size) {
  set_has_mask();
  if (mask_ == &::google::protobuf::internal::kEmptyString) {
    mask_ = new ::std::string;
  }
  mask_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Filter::mutable_mask() {
  set_has_mask();
  if (mask_ == &::google::protobuf::internal::kEmptyString) {
    mask_ = new ::std::string;
  }
  return mask_;
}
inline ::std::string* Filter::release_mask() {
  clear_has_mask();
  if (mask_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = mask_;
    mask_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void Filter::set_allocated_mask(::std::string* mask) {
  if (mask_ != &::google::protobuf::internal::kEmptyString) {
    delete mask_;
  }
  if (mask) {
    set_has_mask();
    mask_ = mask;
  } else {
    clear_has_mask();
    mask_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional uint32 word_offset = 3 [default = 0];
inline bool Filter::has_word_offset() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void Filter::set_has_word_offset() {
  _has_bits_[0] |= 0x00000004u;
}
inline void Filter::clear_has_word_offset() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void Filter::clear_word_offset() {
  word_offset_ = 0u;
  clear_has_word_offset();
}
inline ::google::protobuf::uint32 Filter::word_offset() const {
  return word_offset_;
}
inline void Filter::set_word_offset(::google::protobuf::uint32 value) {
  set_has_word_offset();
  word_offset_ = value;
}

// -------------------------------------------------------------------

// SerializationJobFilters

// repeated .Impinj.STP.Filter tid_filters = 1;
inline int SerializationJobFilters::tid_filters_size() const {
  return tid_filters_.size();
}
inline void SerializationJobFilters::clear_tid_filters() {
  tid_filters_.Clear();
}
inline const ::Impinj::STP::Filter& SerializationJobFilters::tid_filters(int index) const {
  return tid_filters_.Get(index);
}
inline ::Impinj::STP::Filter* SerializationJobFilters::mutable_tid_filters(int index) {
  return tid_filters_.Mutable(index);
}
inline ::Impinj::STP::Filter* SerializationJobFilters::add_tid_filters() {
  return tid_filters_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::Impinj::STP::Filter >&
SerializationJobFilters::tid_filters() const {
  return tid_filters_;
}
inline ::google::protobuf::RepeatedPtrField< ::Impinj::STP::Filter >*
SerializationJobFilters::mutable_tid_filters() {
  return &tid_filters_;
}

// repeated .Impinj.STP.Filter epc_filters = 2;
inline int SerializationJobFilters::epc_filters_size() const {
  return epc_filters_.size();
}
inline void SerializationJobFilters::clear_epc_filters() {
  epc_filters_.Clear();
}
inline const ::Impinj::STP::Filter& SerializationJobFilters::epc_filters(int index) const {
  return epc_filters_.Get(index);
}
inline ::Impinj::STP::Filter* SerializationJobFilters::mutable_epc_filters(int index) {
  return epc_filters_.Mutable(index);
}
inline ::Impinj::STP::Filter* SerializationJobFilters::add_epc_filters() {
  return epc_filters_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::Impinj::STP::Filter >&
SerializationJobFilters::epc_filters() const {
  return epc_filters_;
}
inline ::google::protobuf::RepeatedPtrField< ::Impinj::STP::Filter >*
SerializationJobFilters::mutable_epc_filters() {
  return &epc_filters_;
}

// -------------------------------------------------------------------

// SerializationJob

// required uint32 job_id = 1;
inline bool SerializationJob::has_job_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void SerializationJob::set_has_job_id() {
  _has_bits_[0] |= 0x00000001u;
}
inline void SerializationJob::clear_has_job_id() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void SerializationJob::clear_job_id() {
  job_id_ = 0u;
  clear_has_job_id();
}
inline ::google::protobuf::uint32 SerializationJob::job_id() const {
  return job_id_;
}
inline void SerializationJob::set_job_id(::google::protobuf::uint32 value) {
  set_has_job_id();
  job_id_ = value;
}

// required .Impinj.STP.SerializationJobType job_type = 2;
inline bool SerializationJob::has_job_type() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void SerializationJob::set_has_job_type() {
  _has_bits_[0] |= 0x00000002u;
}
inline void SerializationJob::clear_has_job_type() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void SerializationJob::clear_job_type() {
  job_type_ = 1;
  clear_has_job_type();
}
inline ::Impinj::STP::SerializationJobType SerializationJob::job_type() const {
  return static_cast< ::Impinj::STP::SerializationJobType >(job_type_);
}
inline void SerializationJob::set_job_type(::Impinj::STP::SerializationJobType value) {
  assert(::Impinj::STP::SerializationJobType_IsValid(value));
  set_has_job_type();
  job_type_ = value;
}

// optional .Impinj.STP.SerializationJobCompletionCriteria job_completion_criteria = 3 [default = SERIALIZATION_JOB_COMPLETION_CRITERIA_NONE];
inline bool SerializationJob::has_job_completion_criteria() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void SerializationJob::set_has_job_completion_criteria() {
  _has_bits_[0] |= 0x00000004u;
}
inline void SerializationJob::clear_has_job_completion_criteria() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void SerializationJob::clear_job_completion_criteria() {
  job_completion_criteria_ = 4;
  clear_has_job_completion_criteria();
}
inline ::Impinj::STP::SerializationJobCompletionCriteria SerializationJob::job_completion_criteria() const {
  return static_cast< ::Impinj::STP::SerializationJobCompletionCriteria >(job_completion_criteria_);
}
inline void SerializationJob::set_job_completion_criteria(::Impinj::STP::SerializationJobCompletionCriteria value) {
  assert(::Impinj::STP::SerializationJobCompletionCriteria_IsValid(value));
  set_has_job_completion_criteria();
  job_completion_criteria_ = value;
}

// optional uint32 operation_quantity = 4;
inline bool SerializationJob::has_operation_quantity() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void SerializationJob::set_has_operation_quantity() {
  _has_bits_[0] |= 0x00000008u;
}
inline void SerializationJob::clear_has_operation_quantity() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void SerializationJob::clear_operation_quantity() {
  operation_quantity_ = 0u;
  clear_has_operation_quantity();
}
inline ::google::protobuf::uint32 SerializationJob::operation_quantity() const {
  return operation_quantity_;
}
inline void SerializationJob::set_operation_quantity(::google::protobuf::uint32 value) {
  set_has_operation_quantity();
  operation_quantity_ = value;
}

// optional .Impinj.STP.EPCMemory EPC_memory = 5;
inline bool SerializationJob::has_epc_memory() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void SerializationJob::set_has_epc_memory() {
  _has_bits_[0] |= 0x00000010u;
}
inline void SerializationJob::clear_has_epc_memory() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void SerializationJob::clear_epc_memory() {
  if (epc_memory_ != NULL) epc_memory_->::Impinj::STP::EPCMemory::Clear();
  clear_has_epc_memory();
}
inline const ::Impinj::STP::EPCMemory& SerializationJob::epc_memory() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return epc_memory_ != NULL ? *epc_memory_ : *default_instance().epc_memory_;
#else
  return epc_memory_ != NULL ? *epc_memory_ : *default_instance_->epc_memory_;
#endif
}
inline ::Impinj::STP::EPCMemory* SerializationJob::mutable_epc_memory() {
  set_has_epc_memory();
  if (epc_memory_ == NULL) epc_memory_ = new ::Impinj::STP::EPCMemory;
  return epc_memory_;
}
inline ::Impinj::STP::EPCMemory* SerializationJob::release_epc_memory() {
  clear_has_epc_memory();
  ::Impinj::STP::EPCMemory* temp = epc_memory_;
  epc_memory_ = NULL;
  return temp;
}
inline void SerializationJob::set_allocated_epc_memory(::Impinj::STP::EPCMemory* epc_memory) {
  delete epc_memory_;
  epc_memory_ = epc_memory;
  if (epc_memory) {
    set_has_epc_memory();
  } else {
    clear_has_epc_memory();
  }
}

// optional .Impinj.STP.TIDMemory TID_memory = 6;
inline bool SerializationJob::has_tid_memory() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void SerializationJob::set_has_tid_memory() {
  _has_bits_[0] |= 0x00000020u;
}
inline void SerializationJob::clear_has_tid_memory() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void SerializationJob::clear_tid_memory() {
  if (tid_memory_ != NULL) tid_memory_->::Impinj::STP::TIDMemory::Clear();
  clear_has_tid_memory();
}
inline const ::Impinj::STP::TIDMemory& SerializationJob::tid_memory() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return tid_memory_ != NULL ? *tid_memory_ : *default_instance().tid_memory_;
#else
  return tid_memory_ != NULL ? *tid_memory_ : *default_instance_->tid_memory_;
#endif
}
inline ::Impinj::STP::TIDMemory* SerializationJob::mutable_tid_memory() {
  set_has_tid_memory();
  if (tid_memory_ == NULL) tid_memory_ = new ::Impinj::STP::TIDMemory;
  return tid_memory_;
}
inline ::Impinj::STP::TIDMemory* SerializationJob::release_tid_memory() {
  clear_has_tid_memory();
  ::Impinj::STP::TIDMemory* temp = tid_memory_;
  tid_memory_ = NULL;
  return temp;
}
inline void SerializationJob::set_allocated_tid_memory(::Impinj::STP::TIDMemory* tid_memory) {
  delete tid_memory_;
  tid_memory_ = tid_memory;
  if (tid_memory) {
    set_has_tid_memory();
  } else {
    clear_has_tid_memory();
  }
}

// optional .Impinj.STP.UserMemory user_memory = 7;
inline bool SerializationJob::has_user_memory() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void SerializationJob::set_has_user_memory() {
  _has_bits_[0] |= 0x00000040u;
}
inline void SerializationJob::clear_has_user_memory() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void SerializationJob::clear_user_memory() {
  if (user_memory_ != NULL) user_memory_->::Impinj::STP::UserMemory::Clear();
  clear_has_user_memory();
}
inline const ::Impinj::STP::UserMemory& SerializationJob::user_memory() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return user_memory_ != NULL ? *user_memory_ : *default_instance().user_memory_;
#else
  return user_memory_ != NULL ? *user_memory_ : *default_instance_->user_memory_;
#endif
}
inline ::Impinj::STP::UserMemory* SerializationJob::mutable_user_memory() {
  set_has_user_memory();
  if (user_memory_ == NULL) user_memory_ = new ::Impinj::STP::UserMemory;
  return user_memory_;
}
inline ::Impinj::STP::UserMemory* SerializationJob::release_user_memory() {
  clear_has_user_memory();
  ::Impinj::STP::UserMemory* temp = user_memory_;
  user_memory_ = NULL;
  return temp;
}
inline void SerializationJob::set_allocated_user_memory(::Impinj::STP::UserMemory* user_memory) {
  delete user_memory_;
  user_memory_ = user_memory;
  if (user_memory) {
    set_has_user_memory();
  } else {
    clear_has_user_memory();
  }
}

// optional .Impinj.STP.Password secure_password = 8;
inline bool SerializationJob::has_secure_password() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void SerializationJob::set_has_secure_password() {
  _has_bits_[0] |= 0x00000080u;
}
inline void SerializationJob::clear_has_secure_password() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void SerializationJob::clear_secure_password() {
  if (secure_password_ != NULL) secure_password_->::Impinj::STP::Password::Clear();
  clear_has_secure_password();
}
inline const ::Impinj::STP::Password& SerializationJob::secure_password() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return secure_password_ != NULL ? *secure_password_ : *default_instance().secure_password_;
#else
  return secure_password_ != NULL ? *secure_password_ : *default_instance_->secure_password_;
#endif
}
inline ::Impinj::STP::Password* SerializationJob::mutable_secure_password() {
  set_has_secure_password();
  if (secure_password_ == NULL) secure_password_ = new ::Impinj::STP::Password;
  return secure_password_;
}
inline ::Impinj::STP::Password* SerializationJob::release_secure_password() {
  clear_has_secure_password();
  ::Impinj::STP::Password* temp = secure_password_;
  secure_password_ = NULL;
  return temp;
}
inline void SerializationJob::set_allocated_secure_password(::Impinj::STP::Password* secure_password) {
  delete secure_password_;
  secure_password_ = secure_password;
  if (secure_password) {
    set_has_secure_password();
  } else {
    clear_has_secure_password();
  }
}

// optional .Impinj.STP.Password access_password = 9;
inline bool SerializationJob::has_access_password() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void SerializationJob::set_has_access_password() {
  _has_bits_[0] |= 0x00000100u;
}
inline void SerializationJob::clear_has_access_password() {
  _has_bits_[0] &= ~0x00000100u;
}
inline void SerializationJob::clear_access_password() {
  if (access_password_ != NULL) access_password_->::Impinj::STP::Password::Clear();
  clear_has_access_password();
}
inline const ::Impinj::STP::Password& SerializationJob::access_password() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return access_password_ != NULL ? *access_password_ : *default_instance().access_password_;
#else
  return access_password_ != NULL ? *access_password_ : *default_instance_->access_password_;
#endif
}
inline ::Impinj::STP::Password* SerializationJob::mutable_access_password() {
  set_has_access_password();
  if (access_password_ == NULL) access_password_ = new ::Impinj::STP::Password;
  return access_password_;
}
inline ::Impinj::STP::Password* SerializationJob::release_access_password() {
  clear_has_access_password();
  ::Impinj::STP::Password* temp = access_password_;
  access_password_ = NULL;
  return temp;
}
inline void SerializationJob::set_allocated_access_password(::Impinj::STP::Password* access_password) {
  delete access_password_;
  access_password_ = access_password;
  if (access_password) {
    set_has_access_password();
  } else {
    clear_has_access_password();
  }
}

// optional .Impinj.STP.Password kill_password = 10;
inline bool SerializationJob::has_kill_password() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void SerializationJob::set_has_kill_password() {
  _has_bits_[0] |= 0x00000200u;
}
inline void SerializationJob::clear_has_kill_password() {
  _has_bits_[0] &= ~0x00000200u;
}
inline void SerializationJob::clear_kill_password() {
  if (kill_password_ != NULL) kill_password_->::Impinj::STP::Password::Clear();
  clear_has_kill_password();
}
inline const ::Impinj::STP::Password& SerializationJob::kill_password() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return kill_password_ != NULL ? *kill_password_ : *default_instance().kill_password_;
#else
  return kill_password_ != NULL ? *kill_password_ : *default_instance_->kill_password_;
#endif
}
inline ::Impinj::STP::Password* SerializationJob::mutable_kill_password() {
  set_has_kill_password();
  if (kill_password_ == NULL) kill_password_ = new ::Impinj::STP::Password;
  return kill_password_;
}
inline ::Impinj::STP::Password* SerializationJob::release_kill_password() {
  clear_has_kill_password();
  ::Impinj::STP::Password* temp = kill_password_;
  kill_password_ = NULL;
  return temp;
}
inline void SerializationJob::set_allocated_kill_password(::Impinj::STP::Password* kill_password) {
  delete kill_password_;
  kill_password_ = kill_password;
  if (kill_password) {
    set_has_kill_password();
  } else {
    clear_has_kill_password();
  }
}

// optional .Impinj.STP.LockConfig lock_config = 11;
inline bool SerializationJob::has_lock_config() const {
  return (_has_bits_[0] & 0x00000400u) != 0;
}
inline void SerializationJob::set_has_lock_config() {
  _has_bits_[0] |= 0x00000400u;
}
inline void SerializationJob::clear_has_lock_config() {
  _has_bits_[0] &= ~0x00000400u;
}
inline void SerializationJob::clear_lock_config() {
  if (lock_config_ != NULL) lock_config_->::Impinj::STP::LockConfig::Clear();
  clear_has_lock_config();
}
inline const ::Impinj::STP::LockConfig& SerializationJob::lock_config() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return lock_config_ != NULL ? *lock_config_ : *default_instance().lock_config_;
#else
  return lock_config_ != NULL ? *lock_config_ : *default_instance_->lock_config_;
#endif
}
inline ::Impinj::STP::LockConfig* SerializationJob::mutable_lock_config() {
  set_has_lock_config();
  if (lock_config_ == NULL) lock_config_ = new ::Impinj::STP::LockConfig;
  return lock_config_;
}
inline ::Impinj::STP::LockConfig* SerializationJob::release_lock_config() {
  clear_has_lock_config();
  ::Impinj::STP::LockConfig* temp = lock_config_;
  lock_config_ = NULL;
  return temp;
}
inline void SerializationJob::set_allocated_lock_config(::Impinj::STP::LockConfig* lock_config) {
  delete lock_config_;
  lock_config_ = lock_config;
  if (lock_config) {
    set_has_lock_config();
  } else {
    clear_has_lock_config();
  }
}

// optional .Impinj.STP.BlockPermalockConfig blockpermalock_config = 12;
inline bool SerializationJob::has_blockpermalock_config() const {
  return (_has_bits_[0] & 0x00000800u) != 0;
}
inline void SerializationJob::set_has_blockpermalock_config() {
  _has_bits_[0] |= 0x00000800u;
}
inline void SerializationJob::clear_has_blockpermalock_config() {
  _has_bits_[0] &= ~0x00000800u;
}
inline void SerializationJob::clear_blockpermalock_config() {
  if (blockpermalock_config_ != NULL) blockpermalock_config_->::Impinj::STP::BlockPermalockConfig::Clear();
  clear_has_blockpermalock_config();
}
inline const ::Impinj::STP::BlockPermalockConfig& SerializationJob::blockpermalock_config() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return blockpermalock_config_ != NULL ? *blockpermalock_config_ : *default_instance().blockpermalock_config_;
#else
  return blockpermalock_config_ != NULL ? *blockpermalock_config_ : *default_instance_->blockpermalock_config_;
#endif
}
inline ::Impinj::STP::BlockPermalockConfig* SerializationJob::mutable_blockpermalock_config() {
  set_has_blockpermalock_config();
  if (blockpermalock_config_ == NULL) blockpermalock_config_ = new ::Impinj::STP::BlockPermalockConfig;
  return blockpermalock_config_;
}
inline ::Impinj::STP::BlockPermalockConfig* SerializationJob::release_blockpermalock_config() {
  clear_has_blockpermalock_config();
  ::Impinj::STP::BlockPermalockConfig* temp = blockpermalock_config_;
  blockpermalock_config_ = NULL;
  return temp;
}
inline void SerializationJob::set_allocated_blockpermalock_config(::Impinj::STP::BlockPermalockConfig* blockpermalock_config) {
  delete blockpermalock_config_;
  blockpermalock_config_ = blockpermalock_config;
  if (blockpermalock_config) {
    set_has_blockpermalock_config();
  } else {
    clear_has_blockpermalock_config();
  }
}

// optional bool kill_tag = 16;
inline bool SerializationJob::has_kill_tag() const {
  return (_has_bits_[0] & 0x00001000u) != 0;
}
inline void SerializationJob::set_has_kill_tag() {
  _has_bits_[0] |= 0x00001000u;
}
inline void SerializationJob::clear_has_kill_tag() {
  _has_bits_[0] &= ~0x00001000u;
}
inline void SerializationJob::clear_kill_tag() {
  kill_tag_ = false;
  clear_has_kill_tag();
}
inline bool SerializationJob::kill_tag() const {
  return kill_tag_;
}
inline void SerializationJob::set_kill_tag(bool value) {
  set_has_kill_tag();
  kill_tag_ = value;
}

// optional .Impinj.STP.MonzaR6PFeatureConfig monza_r6p_feature_config = 20;
inline bool SerializationJob::has_monza_r6p_feature_config() const {
  return (_has_bits_[0] & 0x00002000u) != 0;
}
inline void SerializationJob::set_has_monza_r6p_feature_config() {
  _has_bits_[0] |= 0x00002000u;
}
inline void SerializationJob::clear_has_monza_r6p_feature_config() {
  _has_bits_[0] &= ~0x00002000u;
}
inline void SerializationJob::clear_monza_r6p_feature_config() {
  if (monza_r6p_feature_config_ != NULL) monza_r6p_feature_config_->::Impinj::STP::MonzaR6PFeatureConfig::Clear();
  clear_has_monza_r6p_feature_config();
}
inline const ::Impinj::STP::MonzaR6PFeatureConfig& SerializationJob::monza_r6p_feature_config() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return monza_r6p_feature_config_ != NULL ? *monza_r6p_feature_config_ : *default_instance().monza_r6p_feature_config_;
#else
  return monza_r6p_feature_config_ != NULL ? *monza_r6p_feature_config_ : *default_instance_->monza_r6p_feature_config_;
#endif
}
inline ::Impinj::STP::MonzaR6PFeatureConfig* SerializationJob::mutable_monza_r6p_feature_config() {
  set_has_monza_r6p_feature_config();
  if (monza_r6p_feature_config_ == NULL) monza_r6p_feature_config_ = new ::Impinj::STP::MonzaR6PFeatureConfig;
  return monza_r6p_feature_config_;
}
inline ::Impinj::STP::MonzaR6PFeatureConfig* SerializationJob::release_monza_r6p_feature_config() {
  clear_has_monza_r6p_feature_config();
  ::Impinj::STP::MonzaR6PFeatureConfig* temp = monza_r6p_feature_config_;
  monza_r6p_feature_config_ = NULL;
  return temp;
}
inline void SerializationJob::set_allocated_monza_r6p_feature_config(::Impinj::STP::MonzaR6PFeatureConfig* monza_r6p_feature_config) {
  delete monza_r6p_feature_config_;
  monza_r6p_feature_config_ = monza_r6p_feature_config;
  if (monza_r6p_feature_config) {
    set_has_monza_r6p_feature_config();
  } else {
    clear_has_monza_r6p_feature_config();
  }
}

// optional .Impinj.STP.MonzaS6CFeatureConfig monza_s6c_feature_config = 21;
inline bool SerializationJob::has_monza_s6c_feature_config() const {
  return (_has_bits_[0] & 0x00004000u) != 0;
}
inline void SerializationJob::set_has_monza_s6c_feature_config() {
  _has_bits_[0] |= 0x00004000u;
}
inline void SerializationJob::clear_has_monza_s6c_feature_config() {
  _has_bits_[0] &= ~0x00004000u;
}
inline void SerializationJob::clear_monza_s6c_feature_config() {
  if (monza_s6c_feature_config_ != NULL) monza_s6c_feature_config_->::Impinj::STP::MonzaS6CFeatureConfig::Clear();
  clear_has_monza_s6c_feature_config();
}
inline const ::Impinj::STP::MonzaS6CFeatureConfig& SerializationJob::monza_s6c_feature_config() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return monza_s6c_feature_config_ != NULL ? *monza_s6c_feature_config_ : *default_instance().monza_s6c_feature_config_;
#else
  return monza_s6c_feature_config_ != NULL ? *monza_s6c_feature_config_ : *default_instance_->monza_s6c_feature_config_;
#endif
}
inline ::Impinj::STP::MonzaS6CFeatureConfig* SerializationJob::mutable_monza_s6c_feature_config() {
  set_has_monza_s6c_feature_config();
  if (monza_s6c_feature_config_ == NULL) monza_s6c_feature_config_ = new ::Impinj::STP::MonzaS6CFeatureConfig;
  return monza_s6c_feature_config_;
}
inline ::Impinj::STP::MonzaS6CFeatureConfig* SerializationJob::release_monza_s6c_feature_config() {
  clear_has_monza_s6c_feature_config();
  ::Impinj::STP::MonzaS6CFeatureConfig* temp = monza_s6c_feature_config_;
  monza_s6c_feature_config_ = NULL;
  return temp;
}
inline void SerializationJob::set_allocated_monza_s6c_feature_config(::Impinj::STP::MonzaS6CFeatureConfig* monza_s6c_feature_config) {
  delete monza_s6c_feature_config_;
  monza_s6c_feature_config_ = monza_s6c_feature_config;
  if (monza_s6c_feature_config) {
    set_has_monza_s6c_feature_config();
  } else {
    clear_has_monza_s6c_feature_config();
  }
}

// optional .Impinj.STP.MonzaR6FeatureConfig monza_r6_feature_config = 22;
inline bool SerializationJob::has_monza_r6_feature_config() const {
  return (_has_bits_[0] & 0x00008000u) != 0;
}
inline void SerializationJob::set_has_monza_r6_feature_config() {
  _has_bits_[0] |= 0x00008000u;
}
inline void SerializationJob::clear_has_monza_r6_feature_config() {
  _has_bits_[0] &= ~0x00008000u;
}
inline void SerializationJob::clear_monza_r6_feature_config() {
  if (monza_r6_feature_config_ != NULL) monza_r6_feature_config_->::Impinj::STP::MonzaR6FeatureConfig::Clear();
  clear_has_monza_r6_feature_config();
}
inline const ::Impinj::STP::MonzaR6FeatureConfig& SerializationJob::monza_r6_feature_config() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return monza_r6_feature_config_ != NULL ? *monza_r6_feature_config_ : *default_instance().monza_r6_feature_config_;
#else
  return monza_r6_feature_config_ != NULL ? *monza_r6_feature_config_ : *default_instance_->monza_r6_feature_config_;
#endif
}
inline ::Impinj::STP::MonzaR6FeatureConfig* SerializationJob::mutable_monza_r6_feature_config() {
  set_has_monza_r6_feature_config();
  if (monza_r6_feature_config_ == NULL) monza_r6_feature_config_ = new ::Impinj::STP::MonzaR6FeatureConfig;
  return monza_r6_feature_config_;
}
inline ::Impinj::STP::MonzaR6FeatureConfig* SerializationJob::release_monza_r6_feature_config() {
  clear_has_monza_r6_feature_config();
  ::Impinj::STP::MonzaR6FeatureConfig* temp = monza_r6_feature_config_;
  monza_r6_feature_config_ = NULL;
  return temp;
}
inline void SerializationJob::set_allocated_monza_r6_feature_config(::Impinj::STP::MonzaR6FeatureConfig* monza_r6_feature_config) {
  delete monza_r6_feature_config_;
  monza_r6_feature_config_ = monza_r6_feature_config;
  if (monza_r6_feature_config) {
    set_has_monza_r6_feature_config();
  } else {
    clear_has_monza_r6_feature_config();
  }
}

// optional .Impinj.STP.MonzaR6AFeatureConfig monza_r6a_feature_config = 23;
inline bool SerializationJob::has_monza_r6a_feature_config() const {
  return (_has_bits_[0] & 0x00010000u) != 0;
}
inline void SerializationJob::set_has_monza_r6a_feature_config() {
  _has_bits_[0] |= 0x00010000u;
}
inline void SerializationJob::clear_has_monza_r6a_feature_config() {
  _has_bits_[0] &= ~0x00010000u;
}
inline void SerializationJob::clear_monza_r6a_feature_config() {
  if (monza_r6a_feature_config_ != NULL) monza_r6a_feature_config_->::Impinj::STP::MonzaR6AFeatureConfig::Clear();
  clear_has_monza_r6a_feature_config();
}
inline const ::Impinj::STP::MonzaR6AFeatureConfig& SerializationJob::monza_r6a_feature_config() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return monza_r6a_feature_config_ != NULL ? *monza_r6a_feature_config_ : *default_instance().monza_r6a_feature_config_;
#else
  return monza_r6a_feature_config_ != NULL ? *monza_r6a_feature_config_ : *default_instance_->monza_r6a_feature_config_;
#endif
}
inline ::Impinj::STP::MonzaR6AFeatureConfig* SerializationJob::mutable_monza_r6a_feature_config() {
  set_has_monza_r6a_feature_config();
  if (monza_r6a_feature_config_ == NULL) monza_r6a_feature_config_ = new ::Impinj::STP::MonzaR6AFeatureConfig;
  return monza_r6a_feature_config_;
}
inline ::Impinj::STP::MonzaR6AFeatureConfig* SerializationJob::release_monza_r6a_feature_config() {
  clear_has_monza_r6a_feature_config();
  ::Impinj::STP::MonzaR6AFeatureConfig* temp = monza_r6a_feature_config_;
  monza_r6a_feature_config_ = NULL;
  return temp;
}
inline void SerializationJob::set_allocated_monza_r6a_feature_config(::Impinj::STP::MonzaR6AFeatureConfig* monza_r6a_feature_config) {
  delete monza_r6a_feature_config_;
  monza_r6a_feature_config_ = monza_r6a_feature_config;
  if (monza_r6a_feature_config) {
    set_has_monza_r6a_feature_config();
  } else {
    clear_has_monza_r6a_feature_config();
  }
}

// optional uint32 TID_table_size = 17 [default = 100];
inline bool SerializationJob::has_tid_table_size() const {
  return (_has_bits_[0] & 0x00020000u) != 0;
}
inline void SerializationJob::set_has_tid_table_size() {
  _has_bits_[0] |= 0x00020000u;
}
inline void SerializationJob::clear_has_tid_table_size() {
  _has_bits_[0] &= ~0x00020000u;
}
inline void SerializationJob::clear_tid_table_size() {
  tid_table_size_ = 100u;
  clear_has_tid_table_size();
}
inline ::google::protobuf::uint32 SerializationJob::tid_table_size() const {
  return tid_table_size_;
}
inline void SerializationJob::set_tid_table_size(::google::protobuf::uint32 value) {
  set_has_tid_table_size();
  tid_table_size_ = value;
}

// repeated .Impinj.STP.TIDTableEntry TID_table_entries = 14;
inline int SerializationJob::tid_table_entries_size() const {
  return tid_table_entries_.size();
}
inline void SerializationJob::clear_tid_table_entries() {
  tid_table_entries_.Clear();
}
inline const ::Impinj::STP::TIDTableEntry& SerializationJob::tid_table_entries(int index) const {
  return tid_table_entries_.Get(index);
}
inline ::Impinj::STP::TIDTableEntry* SerializationJob::mutable_tid_table_entries(int index) {
  return tid_table_entries_.Mutable(index);
}
inline ::Impinj::STP::TIDTableEntry* SerializationJob::add_tid_table_entries() {
  return tid_table_entries_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::Impinj::STP::TIDTableEntry >&
SerializationJob::tid_table_entries() const {
  return tid_table_entries_;
}
inline ::google::protobuf::RepeatedPtrField< ::Impinj::STP::TIDTableEntry >*
SerializationJob::mutable_tid_table_entries() {
  return &tid_table_entries_;
}

// repeated .Impinj.STP.OrderedListEntry ordered_list_entries = 15;
inline int SerializationJob::ordered_list_entries_size() const {
  return ordered_list_entries_.size();
}
inline void SerializationJob::clear_ordered_list_entries() {
  ordered_list_entries_.Clear();
}
inline const ::Impinj::STP::OrderedListEntry& SerializationJob::ordered_list_entries(int index) const {
  return ordered_list_entries_.Get(index);
}
inline ::Impinj::STP::OrderedListEntry* SerializationJob::mutable_ordered_list_entries(int index) {
  return ordered_list_entries_.Mutable(index);
}
inline ::Impinj::STP::OrderedListEntry* SerializationJob::add_ordered_list_entries() {
  return ordered_list_entries_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::Impinj::STP::OrderedListEntry >&
SerializationJob::ordered_list_entries() const {
  return ordered_list_entries_;
}
inline ::google::protobuf::RepeatedPtrField< ::Impinj::STP::OrderedListEntry >*
SerializationJob::mutable_ordered_list_entries() {
  return &ordered_list_entries_;
}

// optional .Impinj.STP.VoidTagConfig void_tag_config = 18;
inline bool SerializationJob::has_void_tag_config() const {
  return (_has_bits_[0] & 0x00100000u) != 0;
}
inline void SerializationJob::set_has_void_tag_config() {
  _has_bits_[0] |= 0x00100000u;
}
inline void SerializationJob::clear_has_void_tag_config() {
  _has_bits_[0] &= ~0x00100000u;
}
inline void SerializationJob::clear_void_tag_config() {
  if (void_tag_config_ != NULL) void_tag_config_->::Impinj::STP::VoidTagConfig::Clear();
  clear_has_void_tag_config();
}
inline const ::Impinj::STP::VoidTagConfig& SerializationJob::void_tag_config() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return void_tag_config_ != NULL ? *void_tag_config_ : *default_instance().void_tag_config_;
#else
  return void_tag_config_ != NULL ? *void_tag_config_ : *default_instance_->void_tag_config_;
#endif
}
inline ::Impinj::STP::VoidTagConfig* SerializationJob::mutable_void_tag_config() {
  set_has_void_tag_config();
  if (void_tag_config_ == NULL) void_tag_config_ = new ::Impinj::STP::VoidTagConfig;
  return void_tag_config_;
}
inline ::Impinj::STP::VoidTagConfig* SerializationJob::release_void_tag_config() {
  clear_has_void_tag_config();
  ::Impinj::STP::VoidTagConfig* temp = void_tag_config_;
  void_tag_config_ = NULL;
  return temp;
}
inline void SerializationJob::set_allocated_void_tag_config(::Impinj::STP::VoidTagConfig* void_tag_config) {
  delete void_tag_config_;
  void_tag_config_ = void_tag_config;
  if (void_tag_config) {
    set_has_void_tag_config();
  } else {
    clear_has_void_tag_config();
  }
}

// optional .Impinj.STP.SerializationJobFilters filters = 19;
inline bool SerializationJob::has_filters() const {
  return (_has_bits_[0] & 0x00200000u) != 0;
}
inline void SerializationJob::set_has_filters() {
  _has_bits_[0] |= 0x00200000u;
}
inline void SerializationJob::clear_has_filters() {
  _has_bits_[0] &= ~0x00200000u;
}
inline void SerializationJob::clear_filters() {
  if (filters_ != NULL) filters_->::Impinj::STP::SerializationJobFilters::Clear();
  clear_has_filters();
}
inline const ::Impinj::STP::SerializationJobFilters& SerializationJob::filters() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return filters_ != NULL ? *filters_ : *default_instance().filters_;
#else
  return filters_ != NULL ? *filters_ : *default_instance_->filters_;
#endif
}
inline ::Impinj::STP::SerializationJobFilters* SerializationJob::mutable_filters() {
  set_has_filters();
  if (filters_ == NULL) filters_ = new ::Impinj::STP::SerializationJobFilters;
  return filters_;
}
inline ::Impinj::STP::SerializationJobFilters* SerializationJob::release_filters() {
  clear_has_filters();
  ::Impinj::STP::SerializationJobFilters* temp = filters_;
  filters_ = NULL;
  return temp;
}
inline void SerializationJob::set_allocated_filters(::Impinj::STP::SerializationJobFilters* filters) {
  delete filters_;
  filters_ = filters;
  if (filters) {
    set_has_filters();
  } else {
    clear_has_filters();
  }
}

// -------------------------------------------------------------------

// PCWord

// optional bytes data = 1;
inline bool PCWord::has_data() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void PCWord::set_has_data() {
  _has_bits_[0] |= 0x00000001u;
}
inline void PCWord::clear_has_data() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void PCWord::clear_data() {
  if (data_ != &::google::protobuf::internal::kEmptyString) {
    data_->clear();
  }
  clear_has_data();
}
inline const ::std::string& PCWord::data() const {
  return *data_;
}
inline void PCWord::set_data(const ::std::string& value) {
  set_has_data();
  if (data_ == &::google::protobuf::internal::kEmptyString) {
    data_ = new ::std::string;
  }
  data_->assign(value);
}
inline void PCWord::set_data(const char* value) {
  set_has_data();
  if (data_ == &::google::protobuf::internal::kEmptyString) {
    data_ = new ::std::string;
  }
  data_->assign(value);
}
inline void PCWord::set_data(const void* value, size_t size) {
  set_has_data();
  if (data_ == &::google::protobuf::internal::kEmptyString) {
    data_ = new ::std::string;
  }
  data_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* PCWord::mutable_data() {
  set_has_data();
  if (data_ == &::google::protobuf::internal::kEmptyString) {
    data_ = new ::std::string;
  }
  return data_;
}
inline ::std::string* PCWord::release_data() {
  clear_has_data();
  if (data_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = data_;
    data_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void PCWord::set_allocated_data(::std::string* data) {
  if (data_ != &::google::protobuf::internal::kEmptyString) {
    delete data_;
  }
  if (data) {
    set_has_data();
    data_ = data;
  } else {
    clear_has_data();
    data_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional bytes mask = 2;
inline bool PCWord::has_mask() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void PCWord::set_has_mask() {
  _has_bits_[0] |= 0x00000002u;
}
inline void PCWord::clear_has_mask() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void PCWord::clear_mask() {
  if (mask_ != &::google::protobuf::internal::kEmptyString) {
    mask_->clear();
  }
  clear_has_mask();
}
inline const ::std::string& PCWord::mask() const {
  return *mask_;
}
inline void PCWord::set_mask(const ::std::string& value) {
  set_has_mask();
  if (mask_ == &::google::protobuf::internal::kEmptyString) {
    mask_ = new ::std::string;
  }
  mask_->assign(value);
}
inline void PCWord::set_mask(const char* value) {
  set_has_mask();
  if (mask_ == &::google::protobuf::internal::kEmptyString) {
    mask_ = new ::std::string;
  }
  mask_->assign(value);
}
inline void PCWord::set_mask(const void* value, size_t size) {
  set_has_mask();
  if (mask_ == &::google::protobuf::internal::kEmptyString) {
    mask_ = new ::std::string;
  }
  mask_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* PCWord::mutable_mask() {
  set_has_mask();
  if (mask_ == &::google::protobuf::internal::kEmptyString) {
    mask_ = new ::std::string;
  }
  return mask_;
}
inline ::std::string* PCWord::release_mask() {
  clear_has_mask();
  if (mask_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = mask_;
    mask_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void PCWord::set_allocated_mask(::std::string* mask) {
  if (mask_ != &::google::protobuf::internal::kEmptyString) {
    delete mask_;
  }
  if (mask) {
    set_has_mask();
    mask_ = mask;
  } else {
    clear_has_mask();
    mask_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// -------------------------------------------------------------------

// EPCMemory

// optional bytes data = 1;
inline bool EPCMemory::has_data() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void EPCMemory::set_has_data() {
  _has_bits_[0] |= 0x00000001u;
}
inline void EPCMemory::clear_has_data() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void EPCMemory::clear_data() {
  if (data_ != &::google::protobuf::internal::kEmptyString) {
    data_->clear();
  }
  clear_has_data();
}
inline const ::std::string& EPCMemory::data() const {
  return *data_;
}
inline void EPCMemory::set_data(const ::std::string& value) {
  set_has_data();
  if (data_ == &::google::protobuf::internal::kEmptyString) {
    data_ = new ::std::string;
  }
  data_->assign(value);
}
inline void EPCMemory::set_data(const char* value) {
  set_has_data();
  if (data_ == &::google::protobuf::internal::kEmptyString) {
    data_ = new ::std::string;
  }
  data_->assign(value);
}
inline void EPCMemory::set_data(const void* value, size_t size) {
  set_has_data();
  if (data_ == &::google::protobuf::internal::kEmptyString) {
    data_ = new ::std::string;
  }
  data_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* EPCMemory::mutable_data() {
  set_has_data();
  if (data_ == &::google::protobuf::internal::kEmptyString) {
    data_ = new ::std::string;
  }
  return data_;
}
inline ::std::string* EPCMemory::release_data() {
  clear_has_data();
  if (data_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = data_;
    data_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void EPCMemory::set_allocated_data(::std::string* data) {
  if (data_ != &::google::protobuf::internal::kEmptyString) {
    delete data_;
  }
  if (data) {
    set_has_data();
    data_ = data;
  } else {
    clear_has_data();
    data_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional bytes mask = 2;
inline bool EPCMemory::has_mask() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void EPCMemory::set_has_mask() {
  _has_bits_[0] |= 0x00000002u;
}
inline void EPCMemory::clear_has_mask() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void EPCMemory::clear_mask() {
  if (mask_ != &::google::protobuf::internal::kEmptyString) {
    mask_->clear();
  }
  clear_has_mask();
}
inline const ::std::string& EPCMemory::mask() const {
  return *mask_;
}
inline void EPCMemory::set_mask(const ::std::string& value) {
  set_has_mask();
  if (mask_ == &::google::protobuf::internal::kEmptyString) {
    mask_ = new ::std::string;
  }
  mask_->assign(value);
}
inline void EPCMemory::set_mask(const char* value) {
  set_has_mask();
  if (mask_ == &::google::protobuf::internal::kEmptyString) {
    mask_ = new ::std::string;
  }
  mask_->assign(value);
}
inline void EPCMemory::set_mask(const void* value, size_t size) {
  set_has_mask();
  if (mask_ == &::google::protobuf::internal::kEmptyString) {
    mask_ = new ::std::string;
  }
  mask_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* EPCMemory::mutable_mask() {
  set_has_mask();
  if (mask_ == &::google::protobuf::internal::kEmptyString) {
    mask_ = new ::std::string;
  }
  return mask_;
}
inline ::std::string* EPCMemory::release_mask() {
  clear_has_mask();
  if (mask_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = mask_;
    mask_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void EPCMemory::set_allocated_mask(::std::string* mask) {
  if (mask_ != &::google::protobuf::internal::kEmptyString) {
    delete mask_;
  }
  if (mask) {
    set_has_mask();
    mask_ = mask;
  } else {
    clear_has_mask();
    mask_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional .Impinj.STP.Serialization serialization = 3;
inline bool EPCMemory::has_serialization() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void EPCMemory::set_has_serialization() {
  _has_bits_[0] |= 0x00000004u;
}
inline void EPCMemory::clear_has_serialization() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void EPCMemory::clear_serialization() {
  if (serialization_ != NULL) serialization_->::Impinj::STP::Serialization::Clear();
  clear_has_serialization();
}
inline const ::Impinj::STP::Serialization& EPCMemory::serialization() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return serialization_ != NULL ? *serialization_ : *default_instance().serialization_;
#else
  return serialization_ != NULL ? *serialization_ : *default_instance_->serialization_;
#endif
}
inline ::Impinj::STP::Serialization* EPCMemory::mutable_serialization() {
  set_has_serialization();
  if (serialization_ == NULL) serialization_ = new ::Impinj::STP::Serialization;
  return serialization_;
}
inline ::Impinj::STP::Serialization* EPCMemory::release_serialization() {
  clear_has_serialization();
  ::Impinj::STP::Serialization* temp = serialization_;
  serialization_ = NULL;
  return temp;
}
inline void EPCMemory::set_allocated_serialization(::Impinj::STP::Serialization* serialization) {
  delete serialization_;
  serialization_ = serialization;
  if (serialization) {
    set_has_serialization();
  } else {
    clear_has_serialization();
  }
}

// optional .Impinj.STP.PCWord pc_word = 4;
inline bool EPCMemory::has_pc_word() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void EPCMemory::set_has_pc_word() {
  _has_bits_[0] |= 0x00000008u;
}
inline void EPCMemory::clear_has_pc_word() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void EPCMemory::clear_pc_word() {
  if (pc_word_ != NULL) pc_word_->::Impinj::STP::PCWord::Clear();
  clear_has_pc_word();
}
inline const ::Impinj::STP::PCWord& EPCMemory::pc_word() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return pc_word_ != NULL ? *pc_word_ : *default_instance().pc_word_;
#else
  return pc_word_ != NULL ? *pc_word_ : *default_instance_->pc_word_;
#endif
}
inline ::Impinj::STP::PCWord* EPCMemory::mutable_pc_word() {
  set_has_pc_word();
  if (pc_word_ == NULL) pc_word_ = new ::Impinj::STP::PCWord;
  return pc_word_;
}
inline ::Impinj::STP::PCWord* EPCMemory::release_pc_word() {
  clear_has_pc_word();
  ::Impinj::STP::PCWord* temp = pc_word_;
  pc_word_ = NULL;
  return temp;
}
inline void EPCMemory::set_allocated_pc_word(::Impinj::STP::PCWord* pc_word) {
  delete pc_word_;
  pc_word_ = pc_word;
  if (pc_word) {
    set_has_pc_word();
  } else {
    clear_has_pc_word();
  }
}

// -------------------------------------------------------------------

// TIDMemory

// required bytes data = 1;
inline bool TIDMemory::has_data() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TIDMemory::set_has_data() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TIDMemory::clear_has_data() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TIDMemory::clear_data() {
  if (data_ != &::google::protobuf::internal::kEmptyString) {
    data_->clear();
  }
  clear_has_data();
}
inline const ::std::string& TIDMemory::data() const {
  return *data_;
}
inline void TIDMemory::set_data(const ::std::string& value) {
  set_has_data();
  if (data_ == &::google::protobuf::internal::kEmptyString) {
    data_ = new ::std::string;
  }
  data_->assign(value);
}
inline void TIDMemory::set_data(const char* value) {
  set_has_data();
  if (data_ == &::google::protobuf::internal::kEmptyString) {
    data_ = new ::std::string;
  }
  data_->assign(value);
}
inline void TIDMemory::set_data(const void* value, size_t size) {
  set_has_data();
  if (data_ == &::google::protobuf::internal::kEmptyString) {
    data_ = new ::std::string;
  }
  data_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* TIDMemory::mutable_data() {
  set_has_data();
  if (data_ == &::google::protobuf::internal::kEmptyString) {
    data_ = new ::std::string;
  }
  return data_;
}
inline ::std::string* TIDMemory::release_data() {
  clear_has_data();
  if (data_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = data_;
    data_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void TIDMemory::set_allocated_data(::std::string* data) {
  if (data_ != &::google::protobuf::internal::kEmptyString) {
    delete data_;
  }
  if (data) {
    set_has_data();
    data_ = data;
  } else {
    clear_has_data();
    data_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional uint32 word_offset = 3 [default = 0];
inline bool TIDMemory::has_word_offset() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void TIDMemory::set_has_word_offset() {
  _has_bits_[0] |= 0x00000002u;
}
inline void TIDMemory::clear_has_word_offset() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void TIDMemory::clear_word_offset() {
  word_offset_ = 0u;
  clear_has_word_offset();
}
inline ::google::protobuf::uint32 TIDMemory::word_offset() const {
  return word_offset_;
}
inline void TIDMemory::set_word_offset(::google::protobuf::uint32 value) {
  set_has_word_offset();
  word_offset_ = value;
}

// -------------------------------------------------------------------

// Serialization

// required uint32 serialization_bits = 1;
inline bool Serialization::has_serialization_bits() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Serialization::set_has_serialization_bits() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Serialization::clear_has_serialization_bits() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Serialization::clear_serialization_bits() {
  serialization_bits_ = 0u;
  clear_has_serialization_bits();
}
inline ::google::protobuf::uint32 Serialization::serialization_bits() const {
  return serialization_bits_;
}
inline void Serialization::set_serialization_bits(::google::protobuf::uint32 value) {
  set_has_serialization_bits();
  serialization_bits_ = value;
}

// optional .Impinj.STP.MonzaSelfSerialization monza_self_serialization = 6;
inline bool Serialization::has_monza_self_serialization() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void Serialization::set_has_monza_self_serialization() {
  _has_bits_[0] |= 0x00000002u;
}
inline void Serialization::clear_has_monza_self_serialization() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void Serialization::clear_monza_self_serialization() {
  if (monza_self_serialization_ != NULL) monza_self_serialization_->::Impinj::STP::MonzaSelfSerialization::Clear();
  clear_has_monza_self_serialization();
}
inline const ::Impinj::STP::MonzaSelfSerialization& Serialization::monza_self_serialization() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return monza_self_serialization_ != NULL ? *monza_self_serialization_ : *default_instance().monza_self_serialization_;
#else
  return monza_self_serialization_ != NULL ? *monza_self_serialization_ : *default_instance_->monza_self_serialization_;
#endif
}
inline ::Impinj::STP::MonzaSelfSerialization* Serialization::mutable_monza_self_serialization() {
  set_has_monza_self_serialization();
  if (monza_self_serialization_ == NULL) monza_self_serialization_ = new ::Impinj::STP::MonzaSelfSerialization;
  return monza_self_serialization_;
}
inline ::Impinj::STP::MonzaSelfSerialization* Serialization::release_monza_self_serialization() {
  clear_has_monza_self_serialization();
  ::Impinj::STP::MonzaSelfSerialization* temp = monza_self_serialization_;
  monza_self_serialization_ = NULL;
  return temp;
}
inline void Serialization::set_allocated_monza_self_serialization(::Impinj::STP::MonzaSelfSerialization* monza_self_serialization) {
  delete monza_self_serialization_;
  monza_self_serialization_ = monza_self_serialization;
  if (monza_self_serialization) {
    set_has_monza_self_serialization();
  } else {
    clear_has_monza_self_serialization();
  }
}

// optional .Impinj.STP.SerialNumberRange serial_number_range = 7;
inline bool Serialization::has_serial_number_range() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void Serialization::set_has_serial_number_range() {
  _has_bits_[0] |= 0x00000004u;
}
inline void Serialization::clear_has_serial_number_range() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void Serialization::clear_serial_number_range() {
  if (serial_number_range_ != NULL) serial_number_range_->::Impinj::STP::SerialNumberRange::Clear();
  clear_has_serial_number_range();
}
inline const ::Impinj::STP::SerialNumberRange& Serialization::serial_number_range() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return serial_number_range_ != NULL ? *serial_number_range_ : *default_instance().serial_number_range_;
#else
  return serial_number_range_ != NULL ? *serial_number_range_ : *default_instance_->serial_number_range_;
#endif
}
inline ::Impinj::STP::SerialNumberRange* Serialization::mutable_serial_number_range() {
  set_has_serial_number_range();
  if (serial_number_range_ == NULL) serial_number_range_ = new ::Impinj::STP::SerialNumberRange;
  return serial_number_range_;
}
inline ::Impinj::STP::SerialNumberRange* Serialization::release_serial_number_range() {
  clear_has_serial_number_range();
  ::Impinj::STP::SerialNumberRange* temp = serial_number_range_;
  serial_number_range_ = NULL;
  return temp;
}
inline void Serialization::set_allocated_serial_number_range(::Impinj::STP::SerialNumberRange* serial_number_range) {
  delete serial_number_range_;
  serial_number_range_ = serial_number_range;
  if (serial_number_range) {
    set_has_serial_number_range();
  } else {
    clear_has_serial_number_range();
  }
}

// -------------------------------------------------------------------

// MonzaSelfSerialization

// optional string serialization_prefix = 1;
inline bool MonzaSelfSerialization::has_serialization_prefix() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void MonzaSelfSerialization::set_has_serialization_prefix() {
  _has_bits_[0] |= 0x00000001u;
}
inline void MonzaSelfSerialization::clear_has_serialization_prefix() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void MonzaSelfSerialization::clear_serialization_prefix() {
  if (serialization_prefix_ != &::google::protobuf::internal::kEmptyString) {
    serialization_prefix_->clear();
  }
  clear_has_serialization_prefix();
}
inline const ::std::string& MonzaSelfSerialization::serialization_prefix() const {
  return *serialization_prefix_;
}
inline void MonzaSelfSerialization::set_serialization_prefix(const ::std::string& value) {
  set_has_serialization_prefix();
  if (serialization_prefix_ == &::google::protobuf::internal::kEmptyString) {
    serialization_prefix_ = new ::std::string;
  }
  serialization_prefix_->assign(value);
}
inline void MonzaSelfSerialization::set_serialization_prefix(const char* value) {
  set_has_serialization_prefix();
  if (serialization_prefix_ == &::google::protobuf::internal::kEmptyString) {
    serialization_prefix_ = new ::std::string;
  }
  serialization_prefix_->assign(value);
}
inline void MonzaSelfSerialization::set_serialization_prefix(const char* value, size_t size) {
  set_has_serialization_prefix();
  if (serialization_prefix_ == &::google::protobuf::internal::kEmptyString) {
    serialization_prefix_ = new ::std::string;
  }
  serialization_prefix_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* MonzaSelfSerialization::mutable_serialization_prefix() {
  set_has_serialization_prefix();
  if (serialization_prefix_ == &::google::protobuf::internal::kEmptyString) {
    serialization_prefix_ = new ::std::string;
  }
  return serialization_prefix_;
}
inline ::std::string* MonzaSelfSerialization::release_serialization_prefix() {
  clear_has_serialization_prefix();
  if (serialization_prefix_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = serialization_prefix_;
    serialization_prefix_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void MonzaSelfSerialization::set_allocated_serialization_prefix(::std::string* serialization_prefix) {
  if (serialization_prefix_ != &::google::protobuf::internal::kEmptyString) {
    delete serialization_prefix_;
  }
  if (serialization_prefix) {
    set_has_serialization_prefix();
    serialization_prefix_ = serialization_prefix;
  } else {
    clear_has_serialization_prefix();
    serialization_prefix_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// -------------------------------------------------------------------

// SerialNumberRange

// optional uint64 serial_number_range_start = 1;
inline bool SerialNumberRange::has_serial_number_range_start() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void SerialNumberRange::set_has_serial_number_range_start() {
  _has_bits_[0] |= 0x00000001u;
}
inline void SerialNumberRange::clear_has_serial_number_range_start() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void SerialNumberRange::clear_serial_number_range_start() {
  serial_number_range_start_ = GOOGLE_ULONGLONG(0);
  clear_has_serial_number_range_start();
}
inline ::google::protobuf::uint64 SerialNumberRange::serial_number_range_start() const {
  return serial_number_range_start_;
}
inline void SerialNumberRange::set_serial_number_range_start(::google::protobuf::uint64 value) {
  set_has_serial_number_range_start();
  serial_number_range_start_ = value;
}

// optional uint64 serial_number_range_end = 2;
inline bool SerialNumberRange::has_serial_number_range_end() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void SerialNumberRange::set_has_serial_number_range_end() {
  _has_bits_[0] |= 0x00000002u;
}
inline void SerialNumberRange::clear_has_serial_number_range_end() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void SerialNumberRange::clear_serial_number_range_end() {
  serial_number_range_end_ = GOOGLE_ULONGLONG(0);
  clear_has_serial_number_range_end();
}
inline ::google::protobuf::uint64 SerialNumberRange::serial_number_range_end() const {
  return serial_number_range_end_;
}
inline void SerialNumberRange::set_serial_number_range_end(::google::protobuf::uint64 value) {
  set_has_serial_number_range_end();
  serial_number_range_end_ = value;
}

// optional uint32 bit_offset = 3;
inline bool SerialNumberRange::has_bit_offset() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void SerialNumberRange::set_has_bit_offset() {
  _has_bits_[0] |= 0x00000004u;
}
inline void SerialNumberRange::clear_has_bit_offset() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void SerialNumberRange::clear_bit_offset() {
  bit_offset_ = 0u;
  clear_has_bit_offset();
}
inline ::google::protobuf::uint32 SerialNumberRange::bit_offset() const {
  return bit_offset_;
}
inline void SerialNumberRange::set_bit_offset(::google::protobuf::uint32 value) {
  set_has_bit_offset();
  bit_offset_ = value;
}

// optional .Impinj.STP.SerialNumberRangeFormat serial_number_range_format = 4;
inline bool SerialNumberRange::has_serial_number_range_format() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void SerialNumberRange::set_has_serial_number_range_format() {
  _has_bits_[0] |= 0x00000008u;
}
inline void SerialNumberRange::clear_has_serial_number_range_format() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void SerialNumberRange::clear_serial_number_range_format() {
  serial_number_range_format_ = 0;
  clear_has_serial_number_range_format();
}
inline ::Impinj::STP::SerialNumberRangeFormat SerialNumberRange::serial_number_range_format() const {
  return static_cast< ::Impinj::STP::SerialNumberRangeFormat >(serial_number_range_format_);
}
inline void SerialNumberRange::set_serial_number_range_format(::Impinj::STP::SerialNumberRangeFormat value) {
  assert(::Impinj::STP::SerialNumberRangeFormat_IsValid(value));
  set_has_serial_number_range_format();
  serial_number_range_format_ = value;
}

// -------------------------------------------------------------------

// UserMemory

// optional bytes data = 1;
inline bool UserMemory::has_data() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void UserMemory::set_has_data() {
  _has_bits_[0] |= 0x00000001u;
}
inline void UserMemory::clear_has_data() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void UserMemory::clear_data() {
  if (data_ != &::google::protobuf::internal::kEmptyString) {
    data_->clear();
  }
  clear_has_data();
}
inline const ::std::string& UserMemory::data() const {
  return *data_;
}
inline void UserMemory::set_data(const ::std::string& value) {
  set_has_data();
  if (data_ == &::google::protobuf::internal::kEmptyString) {
    data_ = new ::std::string;
  }
  data_->assign(value);
}
inline void UserMemory::set_data(const char* value) {
  set_has_data();
  if (data_ == &::google::protobuf::internal::kEmptyString) {
    data_ = new ::std::string;
  }
  data_->assign(value);
}
inline void UserMemory::set_data(const void* value, size_t size) {
  set_has_data();
  if (data_ == &::google::protobuf::internal::kEmptyString) {
    data_ = new ::std::string;
  }
  data_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* UserMemory::mutable_data() {
  set_has_data();
  if (data_ == &::google::protobuf::internal::kEmptyString) {
    data_ = new ::std::string;
  }
  return data_;
}
inline ::std::string* UserMemory::release_data() {
  clear_has_data();
  if (data_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = data_;
    data_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void UserMemory::set_allocated_data(::std::string* data) {
  if (data_ != &::google::protobuf::internal::kEmptyString) {
    delete data_;
  }
  if (data) {
    set_has_data();
    data_ = data;
  } else {
    clear_has_data();
    data_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional bytes mask = 2;
inline bool UserMemory::has_mask() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void UserMemory::set_has_mask() {
  _has_bits_[0] |= 0x00000002u;
}
inline void UserMemory::clear_has_mask() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void UserMemory::clear_mask() {
  if (mask_ != &::google::protobuf::internal::kEmptyString) {
    mask_->clear();
  }
  clear_has_mask();
}
inline const ::std::string& UserMemory::mask() const {
  return *mask_;
}
inline void UserMemory::set_mask(const ::std::string& value) {
  set_has_mask();
  if (mask_ == &::google::protobuf::internal::kEmptyString) {
    mask_ = new ::std::string;
  }
  mask_->assign(value);
}
inline void UserMemory::set_mask(const char* value) {
  set_has_mask();
  if (mask_ == &::google::protobuf::internal::kEmptyString) {
    mask_ = new ::std::string;
  }
  mask_->assign(value);
}
inline void UserMemory::set_mask(const void* value, size_t size) {
  set_has_mask();
  if (mask_ == &::google::protobuf::internal::kEmptyString) {
    mask_ = new ::std::string;
  }
  mask_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* UserMemory::mutable_mask() {
  set_has_mask();
  if (mask_ == &::google::protobuf::internal::kEmptyString) {
    mask_ = new ::std::string;
  }
  return mask_;
}
inline ::std::string* UserMemory::release_mask() {
  clear_has_mask();
  if (mask_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = mask_;
    mask_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void UserMemory::set_allocated_mask(::std::string* mask) {
  if (mask_ != &::google::protobuf::internal::kEmptyString) {
    delete mask_;
  }
  if (mask) {
    set_has_mask();
    mask_ = mask;
  } else {
    clear_has_mask();
    mask_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional uint32 word_offset = 3 [default = 0];
inline bool UserMemory::has_word_offset() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void UserMemory::set_has_word_offset() {
  _has_bits_[0] |= 0x00000004u;
}
inline void UserMemory::clear_has_word_offset() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void UserMemory::clear_word_offset() {
  word_offset_ = 0u;
  clear_has_word_offset();
}
inline ::google::protobuf::uint32 UserMemory::word_offset() const {
  return word_offset_;
}
inline void UserMemory::set_word_offset(::google::protobuf::uint32 value) {
  set_has_word_offset();
  word_offset_ = value;
}

// optional uint32 word_count_inv = 4 [default = 0];
inline bool UserMemory::has_word_count_inv() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void UserMemory::set_has_word_count_inv() {
  _has_bits_[0] |= 0x00000008u;
}
inline void UserMemory::clear_has_word_count_inv() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void UserMemory::clear_word_count_inv() {
  word_count_inv_ = 0u;
  clear_has_word_count_inv();
}
inline ::google::protobuf::uint32 UserMemory::word_count_inv() const {
  return word_count_inv_;
}
inline void UserMemory::set_word_count_inv(::google::protobuf::uint32 value) {
  set_has_word_count_inv();
  word_count_inv_ = value;
}

// -------------------------------------------------------------------

// Password

// optional .Impinj.STP.PasswordGenerationMethod password_generation_method = 1 [default = PASSWORD_GENERATION_METHOD_STATIC];
inline bool Password::has_password_generation_method() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Password::set_has_password_generation_method() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Password::clear_has_password_generation_method() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Password::clear_password_generation_method() {
  password_generation_method_ = 1;
  clear_has_password_generation_method();
}
inline ::Impinj::STP::PasswordGenerationMethod Password::password_generation_method() const {
  return static_cast< ::Impinj::STP::PasswordGenerationMethod >(password_generation_method_);
}
inline void Password::set_password_generation_method(::Impinj::STP::PasswordGenerationMethod value) {
  assert(::Impinj::STP::PasswordGenerationMethod_IsValid(value));
  set_has_password_generation_method();
  password_generation_method_ = value;
}

// required bytes data = 2;
inline bool Password::has_data() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void Password::set_has_data() {
  _has_bits_[0] |= 0x00000002u;
}
inline void Password::clear_has_data() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void Password::clear_data() {
  if (data_ != &::google::protobuf::internal::kEmptyString) {
    data_->clear();
  }
  clear_has_data();
}
inline const ::std::string& Password::data() const {
  return *data_;
}
inline void Password::set_data(const ::std::string& value) {
  set_has_data();
  if (data_ == &::google::protobuf::internal::kEmptyString) {
    data_ = new ::std::string;
  }
  data_->assign(value);
}
inline void Password::set_data(const char* value) {
  set_has_data();
  if (data_ == &::google::protobuf::internal::kEmptyString) {
    data_ = new ::std::string;
  }
  data_->assign(value);
}
inline void Password::set_data(const void* value, size_t size) {
  set_has_data();
  if (data_ == &::google::protobuf::internal::kEmptyString) {
    data_ = new ::std::string;
  }
  data_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Password::mutable_data() {
  set_has_data();
  if (data_ == &::google::protobuf::internal::kEmptyString) {
    data_ = new ::std::string;
  }
  return data_;
}
inline ::std::string* Password::release_data() {
  clear_has_data();
  if (data_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = data_;
    data_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void Password::set_allocated_data(::std::string* data) {
  if (data_ != &::google::protobuf::internal::kEmptyString) {
    delete data_;
  }
  if (data) {
    set_has_data();
    data_ = data;
  } else {
    clear_has_data();
    data_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// -------------------------------------------------------------------

// LockConfig

// required bytes lock_config_payload = 1;
inline bool LockConfig::has_lock_config_payload() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void LockConfig::set_has_lock_config_payload() {
  _has_bits_[0] |= 0x00000001u;
}
inline void LockConfig::clear_has_lock_config_payload() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void LockConfig::clear_lock_config_payload() {
  if (lock_config_payload_ != &::google::protobuf::internal::kEmptyString) {
    lock_config_payload_->clear();
  }
  clear_has_lock_config_payload();
}
inline const ::std::string& LockConfig::lock_config_payload() const {
  return *lock_config_payload_;
}
inline void LockConfig::set_lock_config_payload(const ::std::string& value) {
  set_has_lock_config_payload();
  if (lock_config_payload_ == &::google::protobuf::internal::kEmptyString) {
    lock_config_payload_ = new ::std::string;
  }
  lock_config_payload_->assign(value);
}
inline void LockConfig::set_lock_config_payload(const char* value) {
  set_has_lock_config_payload();
  if (lock_config_payload_ == &::google::protobuf::internal::kEmptyString) {
    lock_config_payload_ = new ::std::string;
  }
  lock_config_payload_->assign(value);
}
inline void LockConfig::set_lock_config_payload(const void* value, size_t size) {
  set_has_lock_config_payload();
  if (lock_config_payload_ == &::google::protobuf::internal::kEmptyString) {
    lock_config_payload_ = new ::std::string;
  }
  lock_config_payload_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* LockConfig::mutable_lock_config_payload() {
  set_has_lock_config_payload();
  if (lock_config_payload_ == &::google::protobuf::internal::kEmptyString) {
    lock_config_payload_ = new ::std::string;
  }
  return lock_config_payload_;
}
inline ::std::string* LockConfig::release_lock_config_payload() {
  clear_has_lock_config_payload();
  if (lock_config_payload_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = lock_config_payload_;
    lock_config_payload_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void LockConfig::set_allocated_lock_config_payload(::std::string* lock_config_payload) {
  if (lock_config_payload_ != &::google::protobuf::internal::kEmptyString) {
    delete lock_config_payload_;
  }
  if (lock_config_payload) {
    set_has_lock_config_payload();
    lock_config_payload_ = lock_config_payload;
  } else {
    clear_has_lock_config_payload();
    lock_config_payload_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// -------------------------------------------------------------------

// BlockPermalockConfig

// required uint32 block_pointer = 1;
inline bool BlockPermalockConfig::has_block_pointer() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void BlockPermalockConfig::set_has_block_pointer() {
  _has_bits_[0] |= 0x00000001u;
}
inline void BlockPermalockConfig::clear_has_block_pointer() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void BlockPermalockConfig::clear_block_pointer() {
  block_pointer_ = 0u;
  clear_has_block_pointer();
}
inline ::google::protobuf::uint32 BlockPermalockConfig::block_pointer() const {
  return block_pointer_;
}
inline void BlockPermalockConfig::set_block_pointer(::google::protobuf::uint32 value) {
  set_has_block_pointer();
  block_pointer_ = value;
}

// required bytes block_mask = 2;
inline bool BlockPermalockConfig::has_block_mask() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void BlockPermalockConfig::set_has_block_mask() {
  _has_bits_[0] |= 0x00000002u;
}
inline void BlockPermalockConfig::clear_has_block_mask() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void BlockPermalockConfig::clear_block_mask() {
  if (block_mask_ != &::google::protobuf::internal::kEmptyString) {
    block_mask_->clear();
  }
  clear_has_block_mask();
}
inline const ::std::string& BlockPermalockConfig::block_mask() const {
  return *block_mask_;
}
inline void BlockPermalockConfig::set_block_mask(const ::std::string& value) {
  set_has_block_mask();
  if (block_mask_ == &::google::protobuf::internal::kEmptyString) {
    block_mask_ = new ::std::string;
  }
  block_mask_->assign(value);
}
inline void BlockPermalockConfig::set_block_mask(const char* value) {
  set_has_block_mask();
  if (block_mask_ == &::google::protobuf::internal::kEmptyString) {
    block_mask_ = new ::std::string;
  }
  block_mask_->assign(value);
}
inline void BlockPermalockConfig::set_block_mask(const void* value, size_t size) {
  set_has_block_mask();
  if (block_mask_ == &::google::protobuf::internal::kEmptyString) {
    block_mask_ = new ::std::string;
  }
  block_mask_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* BlockPermalockConfig::mutable_block_mask() {
  set_has_block_mask();
  if (block_mask_ == &::google::protobuf::internal::kEmptyString) {
    block_mask_ = new ::std::string;
  }
  return block_mask_;
}
inline ::std::string* BlockPermalockConfig::release_block_mask() {
  clear_has_block_mask();
  if (block_mask_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = block_mask_;
    block_mask_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void BlockPermalockConfig::set_allocated_block_mask(::std::string* block_mask) {
  if (block_mask_ != &::google::protobuf::internal::kEmptyString) {
    delete block_mask_;
  }
  if (block_mask) {
    set_has_block_mask();
    block_mask_ = block_mask;
  } else {
    clear_has_block_mask();
    block_mask_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// -------------------------------------------------------------------

// MonzaR6PFeatureConfig

// optional bool enable_auto_tune = 1;
inline bool MonzaR6PFeatureConfig::has_enable_auto_tune() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void MonzaR6PFeatureConfig::set_has_enable_auto_tune() {
  _has_bits_[0] |= 0x00000001u;
}
inline void MonzaR6PFeatureConfig::clear_has_enable_auto_tune() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void MonzaR6PFeatureConfig::clear_enable_auto_tune() {
  enable_auto_tune_ = false;
  clear_has_enable_auto_tune();
}
inline bool MonzaR6PFeatureConfig::enable_auto_tune() const {
  return enable_auto_tune_;
}
inline void MonzaR6PFeatureConfig::set_enable_auto_tune(bool value) {
  set_has_enable_auto_tune();
  enable_auto_tune_ = value;
}

// optional bool enable_short_range_mode = 2;
inline bool MonzaR6PFeatureConfig::has_enable_short_range_mode() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void MonzaR6PFeatureConfig::set_has_enable_short_range_mode() {
  _has_bits_[0] |= 0x00000002u;
}
inline void MonzaR6PFeatureConfig::clear_has_enable_short_range_mode() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void MonzaR6PFeatureConfig::clear_enable_short_range_mode() {
  enable_short_range_mode_ = false;
  clear_has_enable_short_range_mode();
}
inline bool MonzaR6PFeatureConfig::enable_short_range_mode() const {
  return enable_short_range_mode_;
}
inline void MonzaR6PFeatureConfig::set_enable_short_range_mode(bool value) {
  set_has_enable_short_range_mode();
  enable_short_range_mode_ = value;
}

// optional .Impinj.STP.MonzaR6PMemoryMapConfig memory_map_config = 4;
inline bool MonzaR6PFeatureConfig::has_memory_map_config() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void MonzaR6PFeatureConfig::set_has_memory_map_config() {
  _has_bits_[0] |= 0x00000004u;
}
inline void MonzaR6PFeatureConfig::clear_has_memory_map_config() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void MonzaR6PFeatureConfig::clear_memory_map_config() {
  memory_map_config_ = 0;
  clear_has_memory_map_config();
}
inline ::Impinj::STP::MonzaR6PMemoryMapConfig MonzaR6PFeatureConfig::memory_map_config() const {
  return static_cast< ::Impinj::STP::MonzaR6PMemoryMapConfig >(memory_map_config_);
}
inline void MonzaR6PFeatureConfig::set_memory_map_config(::Impinj::STP::MonzaR6PMemoryMapConfig value) {
  assert(::Impinj::STP::MonzaR6PMemoryMapConfig_IsValid(value));
  set_has_memory_map_config();
  memory_map_config_ = value;
}

// -------------------------------------------------------------------

// MonzaS6CFeatureConfig

// optional bool enable_auto_tune = 1;
inline bool MonzaS6CFeatureConfig::has_enable_auto_tune() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void MonzaS6CFeatureConfig::set_has_enable_auto_tune() {
  _has_bits_[0] |= 0x00000001u;
}
inline void MonzaS6CFeatureConfig::clear_has_enable_auto_tune() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void MonzaS6CFeatureConfig::clear_enable_auto_tune() {
  enable_auto_tune_ = false;
  clear_has_enable_auto_tune();
}
inline bool MonzaS6CFeatureConfig::enable_auto_tune() const {
  return enable_auto_tune_;
}
inline void MonzaS6CFeatureConfig::set_enable_auto_tune(bool value) {
  set_has_enable_auto_tune();
  enable_auto_tune_ = value;
}

// optional bool enable_short_range_mode = 2;
inline bool MonzaS6CFeatureConfig::has_enable_short_range_mode() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void MonzaS6CFeatureConfig::set_has_enable_short_range_mode() {
  _has_bits_[0] |= 0x00000002u;
}
inline void MonzaS6CFeatureConfig::clear_has_enable_short_range_mode() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void MonzaS6CFeatureConfig::clear_enable_short_range_mode() {
  enable_short_range_mode_ = false;
  clear_has_enable_short_range_mode();
}
inline bool MonzaS6CFeatureConfig::enable_short_range_mode() const {
  return enable_short_range_mode_;
}
inline void MonzaS6CFeatureConfig::set_enable_short_range_mode(bool value) {
  set_has_enable_short_range_mode();
  enable_short_range_mode_ = value;
}

// -------------------------------------------------------------------

// MonzaR6FeatureConfig

// optional bool enable_auto_tune = 1;
inline bool MonzaR6FeatureConfig::has_enable_auto_tune() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void MonzaR6FeatureConfig::set_has_enable_auto_tune() {
  _has_bits_[0] |= 0x00000001u;
}
inline void MonzaR6FeatureConfig::clear_has_enable_auto_tune() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void MonzaR6FeatureConfig::clear_enable_auto_tune() {
  enable_auto_tune_ = false;
  clear_has_enable_auto_tune();
}
inline bool MonzaR6FeatureConfig::enable_auto_tune() const {
  return enable_auto_tune_;
}
inline void MonzaR6FeatureConfig::set_enable_auto_tune(bool value) {
  set_has_enable_auto_tune();
  enable_auto_tune_ = value;
}

// -------------------------------------------------------------------

// MonzaR6AFeatureConfig

// optional bool enable_auto_tune = 1;
inline bool MonzaR6AFeatureConfig::has_enable_auto_tune() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void MonzaR6AFeatureConfig::set_has_enable_auto_tune() {
  _has_bits_[0] |= 0x00000001u;
}
inline void MonzaR6AFeatureConfig::clear_has_enable_auto_tune() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void MonzaR6AFeatureConfig::clear_enable_auto_tune() {
  enable_auto_tune_ = false;
  clear_has_enable_auto_tune();
}
inline bool MonzaR6AFeatureConfig::enable_auto_tune() const {
  return enable_auto_tune_;
}
inline void MonzaR6AFeatureConfig::set_enable_auto_tune(bool value) {
  set_has_enable_auto_tune();
  enable_auto_tune_ = value;
}

// optional bool enable_short_range_mode = 2;
inline bool MonzaR6AFeatureConfig::has_enable_short_range_mode() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void MonzaR6AFeatureConfig::set_has_enable_short_range_mode() {
  _has_bits_[0] |= 0x00000002u;
}
inline void MonzaR6AFeatureConfig::clear_has_enable_short_range_mode() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void MonzaR6AFeatureConfig::clear_enable_short_range_mode() {
  enable_short_range_mode_ = false;
  clear_has_enable_short_range_mode();
}
inline bool MonzaR6AFeatureConfig::enable_short_range_mode() const {
  return enable_short_range_mode_;
}
inline void MonzaR6AFeatureConfig::set_enable_short_range_mode(bool value) {
  set_has_enable_short_range_mode();
  enable_short_range_mode_ = value;
}

// -------------------------------------------------------------------

// TIDTableEntry

// required bytes TID = 1;
inline bool TIDTableEntry::has_tid() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TIDTableEntry::set_has_tid() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TIDTableEntry::clear_has_tid() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TIDTableEntry::clear_tid() {
  if (tid_ != &::google::protobuf::internal::kEmptyString) {
    tid_->clear();
  }
  clear_has_tid();
}
inline const ::std::string& TIDTableEntry::tid() const {
  return *tid_;
}
inline void TIDTableEntry::set_tid(const ::std::string& value) {
  set_has_tid();
  if (tid_ == &::google::protobuf::internal::kEmptyString) {
    tid_ = new ::std::string;
  }
  tid_->assign(value);
}
inline void TIDTableEntry::set_tid(const char* value) {
  set_has_tid();
  if (tid_ == &::google::protobuf::internal::kEmptyString) {
    tid_ = new ::std::string;
  }
  tid_->assign(value);
}
inline void TIDTableEntry::set_tid(const void* value, size_t size) {
  set_has_tid();
  if (tid_ == &::google::protobuf::internal::kEmptyString) {
    tid_ = new ::std::string;
  }
  tid_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* TIDTableEntry::mutable_tid() {
  set_has_tid();
  if (tid_ == &::google::protobuf::internal::kEmptyString) {
    tid_ = new ::std::string;
  }
  return tid_;
}
inline ::std::string* TIDTableEntry::release_tid() {
  clear_has_tid();
  if (tid_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = tid_;
    tid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void TIDTableEntry::set_allocated_tid(::std::string* tid) {
  if (tid_ != &::google::protobuf::internal::kEmptyString) {
    delete tid_;
  }
  if (tid) {
    set_has_tid();
    tid_ = tid;
  } else {
    clear_has_tid();
    tid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional .Impinj.STP.EPCMemory EPC_memory = 3;
inline bool TIDTableEntry::has_epc_memory() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void TIDTableEntry::set_has_epc_memory() {
  _has_bits_[0] |= 0x00000002u;
}
inline void TIDTableEntry::clear_has_epc_memory() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void TIDTableEntry::clear_epc_memory() {
  if (epc_memory_ != NULL) epc_memory_->::Impinj::STP::EPCMemory::Clear();
  clear_has_epc_memory();
}
inline const ::Impinj::STP::EPCMemory& TIDTableEntry::epc_memory() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return epc_memory_ != NULL ? *epc_memory_ : *default_instance().epc_memory_;
#else
  return epc_memory_ != NULL ? *epc_memory_ : *default_instance_->epc_memory_;
#endif
}
inline ::Impinj::STP::EPCMemory* TIDTableEntry::mutable_epc_memory() {
  set_has_epc_memory();
  if (epc_memory_ == NULL) epc_memory_ = new ::Impinj::STP::EPCMemory;
  return epc_memory_;
}
inline ::Impinj::STP::EPCMemory* TIDTableEntry::release_epc_memory() {
  clear_has_epc_memory();
  ::Impinj::STP::EPCMemory* temp = epc_memory_;
  epc_memory_ = NULL;
  return temp;
}
inline void TIDTableEntry::set_allocated_epc_memory(::Impinj::STP::EPCMemory* epc_memory) {
  delete epc_memory_;
  epc_memory_ = epc_memory;
  if (epc_memory) {
    set_has_epc_memory();
  } else {
    clear_has_epc_memory();
  }
}

// optional .Impinj.STP.TIDMemory TID_memory = 4;
inline bool TIDTableEntry::has_tid_memory() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void TIDTableEntry::set_has_tid_memory() {
  _has_bits_[0] |= 0x00000004u;
}
inline void TIDTableEntry::clear_has_tid_memory() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void TIDTableEntry::clear_tid_memory() {
  if (tid_memory_ != NULL) tid_memory_->::Impinj::STP::TIDMemory::Clear();
  clear_has_tid_memory();
}
inline const ::Impinj::STP::TIDMemory& TIDTableEntry::tid_memory() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return tid_memory_ != NULL ? *tid_memory_ : *default_instance().tid_memory_;
#else
  return tid_memory_ != NULL ? *tid_memory_ : *default_instance_->tid_memory_;
#endif
}
inline ::Impinj::STP::TIDMemory* TIDTableEntry::mutable_tid_memory() {
  set_has_tid_memory();
  if (tid_memory_ == NULL) tid_memory_ = new ::Impinj::STP::TIDMemory;
  return tid_memory_;
}
inline ::Impinj::STP::TIDMemory* TIDTableEntry::release_tid_memory() {
  clear_has_tid_memory();
  ::Impinj::STP::TIDMemory* temp = tid_memory_;
  tid_memory_ = NULL;
  return temp;
}
inline void TIDTableEntry::set_allocated_tid_memory(::Impinj::STP::TIDMemory* tid_memory) {
  delete tid_memory_;
  tid_memory_ = tid_memory;
  if (tid_memory) {
    set_has_tid_memory();
  } else {
    clear_has_tid_memory();
  }
}

// optional .Impinj.STP.UserMemory user_memory = 5;
inline bool TIDTableEntry::has_user_memory() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void TIDTableEntry::set_has_user_memory() {
  _has_bits_[0] |= 0x00000008u;
}
inline void TIDTableEntry::clear_has_user_memory() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void TIDTableEntry::clear_user_memory() {
  if (user_memory_ != NULL) user_memory_->::Impinj::STP::UserMemory::Clear();
  clear_has_user_memory();
}
inline const ::Impinj::STP::UserMemory& TIDTableEntry::user_memory() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return user_memory_ != NULL ? *user_memory_ : *default_instance().user_memory_;
#else
  return user_memory_ != NULL ? *user_memory_ : *default_instance_->user_memory_;
#endif
}
inline ::Impinj::STP::UserMemory* TIDTableEntry::mutable_user_memory() {
  set_has_user_memory();
  if (user_memory_ == NULL) user_memory_ = new ::Impinj::STP::UserMemory;
  return user_memory_;
}
inline ::Impinj::STP::UserMemory* TIDTableEntry::release_user_memory() {
  clear_has_user_memory();
  ::Impinj::STP::UserMemory* temp = user_memory_;
  user_memory_ = NULL;
  return temp;
}
inline void TIDTableEntry::set_allocated_user_memory(::Impinj::STP::UserMemory* user_memory) {
  delete user_memory_;
  user_memory_ = user_memory;
  if (user_memory) {
    set_has_user_memory();
  } else {
    clear_has_user_memory();
  }
}

// optional .Impinj.STP.Password secure_password = 6;
inline bool TIDTableEntry::has_secure_password() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void TIDTableEntry::set_has_secure_password() {
  _has_bits_[0] |= 0x00000010u;
}
inline void TIDTableEntry::clear_has_secure_password() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void TIDTableEntry::clear_secure_password() {
  if (secure_password_ != NULL) secure_password_->::Impinj::STP::Password::Clear();
  clear_has_secure_password();
}
inline const ::Impinj::STP::Password& TIDTableEntry::secure_password() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return secure_password_ != NULL ? *secure_password_ : *default_instance().secure_password_;
#else
  return secure_password_ != NULL ? *secure_password_ : *default_instance_->secure_password_;
#endif
}
inline ::Impinj::STP::Password* TIDTableEntry::mutable_secure_password() {
  set_has_secure_password();
  if (secure_password_ == NULL) secure_password_ = new ::Impinj::STP::Password;
  return secure_password_;
}
inline ::Impinj::STP::Password* TIDTableEntry::release_secure_password() {
  clear_has_secure_password();
  ::Impinj::STP::Password* temp = secure_password_;
  secure_password_ = NULL;
  return temp;
}
inline void TIDTableEntry::set_allocated_secure_password(::Impinj::STP::Password* secure_password) {
  delete secure_password_;
  secure_password_ = secure_password;
  if (secure_password) {
    set_has_secure_password();
  } else {
    clear_has_secure_password();
  }
}

// optional .Impinj.STP.Password access_password = 7;
inline bool TIDTableEntry::has_access_password() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void TIDTableEntry::set_has_access_password() {
  _has_bits_[0] |= 0x00000020u;
}
inline void TIDTableEntry::clear_has_access_password() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void TIDTableEntry::clear_access_password() {
  if (access_password_ != NULL) access_password_->::Impinj::STP::Password::Clear();
  clear_has_access_password();
}
inline const ::Impinj::STP::Password& TIDTableEntry::access_password() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return access_password_ != NULL ? *access_password_ : *default_instance().access_password_;
#else
  return access_password_ != NULL ? *access_password_ : *default_instance_->access_password_;
#endif
}
inline ::Impinj::STP::Password* TIDTableEntry::mutable_access_password() {
  set_has_access_password();
  if (access_password_ == NULL) access_password_ = new ::Impinj::STP::Password;
  return access_password_;
}
inline ::Impinj::STP::Password* TIDTableEntry::release_access_password() {
  clear_has_access_password();
  ::Impinj::STP::Password* temp = access_password_;
  access_password_ = NULL;
  return temp;
}
inline void TIDTableEntry::set_allocated_access_password(::Impinj::STP::Password* access_password) {
  delete access_password_;
  access_password_ = access_password;
  if (access_password) {
    set_has_access_password();
  } else {
    clear_has_access_password();
  }
}

// optional .Impinj.STP.Password kill_password = 8;
inline bool TIDTableEntry::has_kill_password() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void TIDTableEntry::set_has_kill_password() {
  _has_bits_[0] |= 0x00000040u;
}
inline void TIDTableEntry::clear_has_kill_password() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void TIDTableEntry::clear_kill_password() {
  if (kill_password_ != NULL) kill_password_->::Impinj::STP::Password::Clear();
  clear_has_kill_password();
}
inline const ::Impinj::STP::Password& TIDTableEntry::kill_password() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return kill_password_ != NULL ? *kill_password_ : *default_instance().kill_password_;
#else
  return kill_password_ != NULL ? *kill_password_ : *default_instance_->kill_password_;
#endif
}
inline ::Impinj::STP::Password* TIDTableEntry::mutable_kill_password() {
  set_has_kill_password();
  if (kill_password_ == NULL) kill_password_ = new ::Impinj::STP::Password;
  return kill_password_;
}
inline ::Impinj::STP::Password* TIDTableEntry::release_kill_password() {
  clear_has_kill_password();
  ::Impinj::STP::Password* temp = kill_password_;
  kill_password_ = NULL;
  return temp;
}
inline void TIDTableEntry::set_allocated_kill_password(::Impinj::STP::Password* kill_password) {
  delete kill_password_;
  kill_password_ = kill_password;
  if (kill_password) {
    set_has_kill_password();
  } else {
    clear_has_kill_password();
  }
}

// optional .Impinj.STP.LockConfig lock_config = 9;
inline bool TIDTableEntry::has_lock_config() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void TIDTableEntry::set_has_lock_config() {
  _has_bits_[0] |= 0x00000080u;
}
inline void TIDTableEntry::clear_has_lock_config() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void TIDTableEntry::clear_lock_config() {
  if (lock_config_ != NULL) lock_config_->::Impinj::STP::LockConfig::Clear();
  clear_has_lock_config();
}
inline const ::Impinj::STP::LockConfig& TIDTableEntry::lock_config() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return lock_config_ != NULL ? *lock_config_ : *default_instance().lock_config_;
#else
  return lock_config_ != NULL ? *lock_config_ : *default_instance_->lock_config_;
#endif
}
inline ::Impinj::STP::LockConfig* TIDTableEntry::mutable_lock_config() {
  set_has_lock_config();
  if (lock_config_ == NULL) lock_config_ = new ::Impinj::STP::LockConfig;
  return lock_config_;
}
inline ::Impinj::STP::LockConfig* TIDTableEntry::release_lock_config() {
  clear_has_lock_config();
  ::Impinj::STP::LockConfig* temp = lock_config_;
  lock_config_ = NULL;
  return temp;
}
inline void TIDTableEntry::set_allocated_lock_config(::Impinj::STP::LockConfig* lock_config) {
  delete lock_config_;
  lock_config_ = lock_config;
  if (lock_config) {
    set_has_lock_config();
  } else {
    clear_has_lock_config();
  }
}

// optional .Impinj.STP.BlockPermalockConfig blockpermalock_config = 10;
inline bool TIDTableEntry::has_blockpermalock_config() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void TIDTableEntry::set_has_blockpermalock_config() {
  _has_bits_[0] |= 0x00000100u;
}
inline void TIDTableEntry::clear_has_blockpermalock_config() {
  _has_bits_[0] &= ~0x00000100u;
}
inline void TIDTableEntry::clear_blockpermalock_config() {
  if (blockpermalock_config_ != NULL) blockpermalock_config_->::Impinj::STP::BlockPermalockConfig::Clear();
  clear_has_blockpermalock_config();
}
inline const ::Impinj::STP::BlockPermalockConfig& TIDTableEntry::blockpermalock_config() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return blockpermalock_config_ != NULL ? *blockpermalock_config_ : *default_instance().blockpermalock_config_;
#else
  return blockpermalock_config_ != NULL ? *blockpermalock_config_ : *default_instance_->blockpermalock_config_;
#endif
}
inline ::Impinj::STP::BlockPermalockConfig* TIDTableEntry::mutable_blockpermalock_config() {
  set_has_blockpermalock_config();
  if (blockpermalock_config_ == NULL) blockpermalock_config_ = new ::Impinj::STP::BlockPermalockConfig;
  return blockpermalock_config_;
}
inline ::Impinj::STP::BlockPermalockConfig* TIDTableEntry::release_blockpermalock_config() {
  clear_has_blockpermalock_config();
  ::Impinj::STP::BlockPermalockConfig* temp = blockpermalock_config_;
  blockpermalock_config_ = NULL;
  return temp;
}
inline void TIDTableEntry::set_allocated_blockpermalock_config(::Impinj::STP::BlockPermalockConfig* blockpermalock_config) {
  delete blockpermalock_config_;
  blockpermalock_config_ = blockpermalock_config;
  if (blockpermalock_config) {
    set_has_blockpermalock_config();
  } else {
    clear_has_blockpermalock_config();
  }
}

// optional bool kill_tag = 12;
inline bool TIDTableEntry::has_kill_tag() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void TIDTableEntry::set_has_kill_tag() {
  _has_bits_[0] |= 0x00000200u;
}
inline void TIDTableEntry::clear_has_kill_tag() {
  _has_bits_[0] &= ~0x00000200u;
}
inline void TIDTableEntry::clear_kill_tag() {
  kill_tag_ = false;
  clear_has_kill_tag();
}
inline bool TIDTableEntry::kill_tag() const {
  return kill_tag_;
}
inline void TIDTableEntry::set_kill_tag(bool value) {
  set_has_kill_tag();
  kill_tag_ = value;
}

// optional bool void_tag = 13;
inline bool TIDTableEntry::has_void_tag() const {
  return (_has_bits_[0] & 0x00000400u) != 0;
}
inline void TIDTableEntry::set_has_void_tag() {
  _has_bits_[0] |= 0x00000400u;
}
inline void TIDTableEntry::clear_has_void_tag() {
  _has_bits_[0] &= ~0x00000400u;
}
inline void TIDTableEntry::clear_void_tag() {
  void_tag_ = false;
  clear_has_void_tag();
}
inline bool TIDTableEntry::void_tag() const {
  return void_tag_;
}
inline void TIDTableEntry::set_void_tag(bool value) {
  set_has_void_tag();
  void_tag_ = value;
}

// optional .Impinj.STP.MonzaR6PFeatureConfig monza_r6p_feature_config = 14;
inline bool TIDTableEntry::has_monza_r6p_feature_config() const {
  return (_has_bits_[0] & 0x00000800u) != 0;
}
inline void TIDTableEntry::set_has_monza_r6p_feature_config() {
  _has_bits_[0] |= 0x00000800u;
}
inline void TIDTableEntry::clear_has_monza_r6p_feature_config() {
  _has_bits_[0] &= ~0x00000800u;
}
inline void TIDTableEntry::clear_monza_r6p_feature_config() {
  if (monza_r6p_feature_config_ != NULL) monza_r6p_feature_config_->::Impinj::STP::MonzaR6PFeatureConfig::Clear();
  clear_has_monza_r6p_feature_config();
}
inline const ::Impinj::STP::MonzaR6PFeatureConfig& TIDTableEntry::monza_r6p_feature_config() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return monza_r6p_feature_config_ != NULL ? *monza_r6p_feature_config_ : *default_instance().monza_r6p_feature_config_;
#else
  return monza_r6p_feature_config_ != NULL ? *monza_r6p_feature_config_ : *default_instance_->monza_r6p_feature_config_;
#endif
}
inline ::Impinj::STP::MonzaR6PFeatureConfig* TIDTableEntry::mutable_monza_r6p_feature_config() {
  set_has_monza_r6p_feature_config();
  if (monza_r6p_feature_config_ == NULL) monza_r6p_feature_config_ = new ::Impinj::STP::MonzaR6PFeatureConfig;
  return monza_r6p_feature_config_;
}
inline ::Impinj::STP::MonzaR6PFeatureConfig* TIDTableEntry::release_monza_r6p_feature_config() {
  clear_has_monza_r6p_feature_config();
  ::Impinj::STP::MonzaR6PFeatureConfig* temp = monza_r6p_feature_config_;
  monza_r6p_feature_config_ = NULL;
  return temp;
}
inline void TIDTableEntry::set_allocated_monza_r6p_feature_config(::Impinj::STP::MonzaR6PFeatureConfig* monza_r6p_feature_config) {
  delete monza_r6p_feature_config_;
  monza_r6p_feature_config_ = monza_r6p_feature_config;
  if (monza_r6p_feature_config) {
    set_has_monza_r6p_feature_config();
  } else {
    clear_has_monza_r6p_feature_config();
  }
}

// optional .Impinj.STP.MonzaS6CFeatureConfig monza_s6c_feature_config = 15;
inline bool TIDTableEntry::has_monza_s6c_feature_config() const {
  return (_has_bits_[0] & 0x00001000u) != 0;
}
inline void TIDTableEntry::set_has_monza_s6c_feature_config() {
  _has_bits_[0] |= 0x00001000u;
}
inline void TIDTableEntry::clear_has_monza_s6c_feature_config() {
  _has_bits_[0] &= ~0x00001000u;
}
inline void TIDTableEntry::clear_monza_s6c_feature_config() {
  if (monza_s6c_feature_config_ != NULL) monza_s6c_feature_config_->::Impinj::STP::MonzaS6CFeatureConfig::Clear();
  clear_has_monza_s6c_feature_config();
}
inline const ::Impinj::STP::MonzaS6CFeatureConfig& TIDTableEntry::monza_s6c_feature_config() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return monza_s6c_feature_config_ != NULL ? *monza_s6c_feature_config_ : *default_instance().monza_s6c_feature_config_;
#else
  return monza_s6c_feature_config_ != NULL ? *monza_s6c_feature_config_ : *default_instance_->monza_s6c_feature_config_;
#endif
}
inline ::Impinj::STP::MonzaS6CFeatureConfig* TIDTableEntry::mutable_monza_s6c_feature_config() {
  set_has_monza_s6c_feature_config();
  if (monza_s6c_feature_config_ == NULL) monza_s6c_feature_config_ = new ::Impinj::STP::MonzaS6CFeatureConfig;
  return monza_s6c_feature_config_;
}
inline ::Impinj::STP::MonzaS6CFeatureConfig* TIDTableEntry::release_monza_s6c_feature_config() {
  clear_has_monza_s6c_feature_config();
  ::Impinj::STP::MonzaS6CFeatureConfig* temp = monza_s6c_feature_config_;
  monza_s6c_feature_config_ = NULL;
  return temp;
}
inline void TIDTableEntry::set_allocated_monza_s6c_feature_config(::Impinj::STP::MonzaS6CFeatureConfig* monza_s6c_feature_config) {
  delete monza_s6c_feature_config_;
  monza_s6c_feature_config_ = monza_s6c_feature_config;
  if (monza_s6c_feature_config) {
    set_has_monza_s6c_feature_config();
  } else {
    clear_has_monza_s6c_feature_config();
  }
}

// optional .Impinj.STP.MonzaR6FeatureConfig monza_r6_feature_config = 16;
inline bool TIDTableEntry::has_monza_r6_feature_config() const {
  return (_has_bits_[0] & 0x00002000u) != 0;
}
inline void TIDTableEntry::set_has_monza_r6_feature_config() {
  _has_bits_[0] |= 0x00002000u;
}
inline void TIDTableEntry::clear_has_monza_r6_feature_config() {
  _has_bits_[0] &= ~0x00002000u;
}
inline void TIDTableEntry::clear_monza_r6_feature_config() {
  if (monza_r6_feature_config_ != NULL) monza_r6_feature_config_->::Impinj::STP::MonzaR6FeatureConfig::Clear();
  clear_has_monza_r6_feature_config();
}
inline const ::Impinj::STP::MonzaR6FeatureConfig& TIDTableEntry::monza_r6_feature_config() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return monza_r6_feature_config_ != NULL ? *monza_r6_feature_config_ : *default_instance().monza_r6_feature_config_;
#else
  return monza_r6_feature_config_ != NULL ? *monza_r6_feature_config_ : *default_instance_->monza_r6_feature_config_;
#endif
}
inline ::Impinj::STP::MonzaR6FeatureConfig* TIDTableEntry::mutable_monza_r6_feature_config() {
  set_has_monza_r6_feature_config();
  if (monza_r6_feature_config_ == NULL) monza_r6_feature_config_ = new ::Impinj::STP::MonzaR6FeatureConfig;
  return monza_r6_feature_config_;
}
inline ::Impinj::STP::MonzaR6FeatureConfig* TIDTableEntry::release_monza_r6_feature_config() {
  clear_has_monza_r6_feature_config();
  ::Impinj::STP::MonzaR6FeatureConfig* temp = monza_r6_feature_config_;
  monza_r6_feature_config_ = NULL;
  return temp;
}
inline void TIDTableEntry::set_allocated_monza_r6_feature_config(::Impinj::STP::MonzaR6FeatureConfig* monza_r6_feature_config) {
  delete monza_r6_feature_config_;
  monza_r6_feature_config_ = monza_r6_feature_config;
  if (monza_r6_feature_config) {
    set_has_monza_r6_feature_config();
  } else {
    clear_has_monza_r6_feature_config();
  }
}

// optional .Impinj.STP.MonzaR6AFeatureConfig monza_r6a_feature_config = 17;
inline bool TIDTableEntry::has_monza_r6a_feature_config() const {
  return (_has_bits_[0] & 0x00004000u) != 0;
}
inline void TIDTableEntry::set_has_monza_r6a_feature_config() {
  _has_bits_[0] |= 0x00004000u;
}
inline void TIDTableEntry::clear_has_monza_r6a_feature_config() {
  _has_bits_[0] &= ~0x00004000u;
}
inline void TIDTableEntry::clear_monza_r6a_feature_config() {
  if (monza_r6a_feature_config_ != NULL) monza_r6a_feature_config_->::Impinj::STP::MonzaR6AFeatureConfig::Clear();
  clear_has_monza_r6a_feature_config();
}
inline const ::Impinj::STP::MonzaR6AFeatureConfig& TIDTableEntry::monza_r6a_feature_config() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return monza_r6a_feature_config_ != NULL ? *monza_r6a_feature_config_ : *default_instance().monza_r6a_feature_config_;
#else
  return monza_r6a_feature_config_ != NULL ? *monza_r6a_feature_config_ : *default_instance_->monza_r6a_feature_config_;
#endif
}
inline ::Impinj::STP::MonzaR6AFeatureConfig* TIDTableEntry::mutable_monza_r6a_feature_config() {
  set_has_monza_r6a_feature_config();
  if (monza_r6a_feature_config_ == NULL) monza_r6a_feature_config_ = new ::Impinj::STP::MonzaR6AFeatureConfig;
  return monza_r6a_feature_config_;
}
inline ::Impinj::STP::MonzaR6AFeatureConfig* TIDTableEntry::release_monza_r6a_feature_config() {
  clear_has_monza_r6a_feature_config();
  ::Impinj::STP::MonzaR6AFeatureConfig* temp = monza_r6a_feature_config_;
  monza_r6a_feature_config_ = NULL;
  return temp;
}
inline void TIDTableEntry::set_allocated_monza_r6a_feature_config(::Impinj::STP::MonzaR6AFeatureConfig* monza_r6a_feature_config) {
  delete monza_r6a_feature_config_;
  monza_r6a_feature_config_ = monza_r6a_feature_config;
  if (monza_r6a_feature_config) {
    set_has_monza_r6a_feature_config();
  } else {
    clear_has_monza_r6a_feature_config();
  }
}

// -------------------------------------------------------------------

// TIDTableEntries

// repeated .Impinj.STP.TIDTableEntry tid_table_entries = 1;
inline int TIDTableEntries::tid_table_entries_size() const {
  return tid_table_entries_.size();
}
inline void TIDTableEntries::clear_tid_table_entries() {
  tid_table_entries_.Clear();
}
inline const ::Impinj::STP::TIDTableEntry& TIDTableEntries::tid_table_entries(int index) const {
  return tid_table_entries_.Get(index);
}
inline ::Impinj::STP::TIDTableEntry* TIDTableEntries::mutable_tid_table_entries(int index) {
  return tid_table_entries_.Mutable(index);
}
inline ::Impinj::STP::TIDTableEntry* TIDTableEntries::add_tid_table_entries() {
  return tid_table_entries_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::Impinj::STP::TIDTableEntry >&
TIDTableEntries::tid_table_entries() const {
  return tid_table_entries_;
}
inline ::google::protobuf::RepeatedPtrField< ::Impinj::STP::TIDTableEntry >*
TIDTableEntries::mutable_tid_table_entries() {
  return &tid_table_entries_;
}

// -------------------------------------------------------------------

// OrderedListEntry

// required .Impinj.STP.EPCMemory EPC_memory = 1;
inline bool OrderedListEntry::has_epc_memory() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void OrderedListEntry::set_has_epc_memory() {
  _has_bits_[0] |= 0x00000001u;
}
inline void OrderedListEntry::clear_has_epc_memory() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void OrderedListEntry::clear_epc_memory() {
  if (epc_memory_ != NULL) epc_memory_->::Impinj::STP::EPCMemory::Clear();
  clear_has_epc_memory();
}
inline const ::Impinj::STP::EPCMemory& OrderedListEntry::epc_memory() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return epc_memory_ != NULL ? *epc_memory_ : *default_instance().epc_memory_;
#else
  return epc_memory_ != NULL ? *epc_memory_ : *default_instance_->epc_memory_;
#endif
}
inline ::Impinj::STP::EPCMemory* OrderedListEntry::mutable_epc_memory() {
  set_has_epc_memory();
  if (epc_memory_ == NULL) epc_memory_ = new ::Impinj::STP::EPCMemory;
  return epc_memory_;
}
inline ::Impinj::STP::EPCMemory* OrderedListEntry::release_epc_memory() {
  clear_has_epc_memory();
  ::Impinj::STP::EPCMemory* temp = epc_memory_;
  epc_memory_ = NULL;
  return temp;
}
inline void OrderedListEntry::set_allocated_epc_memory(::Impinj::STP::EPCMemory* epc_memory) {
  delete epc_memory_;
  epc_memory_ = epc_memory;
  if (epc_memory) {
    set_has_epc_memory();
  } else {
    clear_has_epc_memory();
  }
}

// optional .Impinj.STP.UserMemory user_memory = 2;
inline bool OrderedListEntry::has_user_memory() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void OrderedListEntry::set_has_user_memory() {
  _has_bits_[0] |= 0x00000002u;
}
inline void OrderedListEntry::clear_has_user_memory() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void OrderedListEntry::clear_user_memory() {
  if (user_memory_ != NULL) user_memory_->::Impinj::STP::UserMemory::Clear();
  clear_has_user_memory();
}
inline const ::Impinj::STP::UserMemory& OrderedListEntry::user_memory() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return user_memory_ != NULL ? *user_memory_ : *default_instance().user_memory_;
#else
  return user_memory_ != NULL ? *user_memory_ : *default_instance_->user_memory_;
#endif
}
inline ::Impinj::STP::UserMemory* OrderedListEntry::mutable_user_memory() {
  set_has_user_memory();
  if (user_memory_ == NULL) user_memory_ = new ::Impinj::STP::UserMemory;
  return user_memory_;
}
inline ::Impinj::STP::UserMemory* OrderedListEntry::release_user_memory() {
  clear_has_user_memory();
  ::Impinj::STP::UserMemory* temp = user_memory_;
  user_memory_ = NULL;
  return temp;
}
inline void OrderedListEntry::set_allocated_user_memory(::Impinj::STP::UserMemory* user_memory) {
  delete user_memory_;
  user_memory_ = user_memory;
  if (user_memory) {
    set_has_user_memory();
  } else {
    clear_has_user_memory();
  }
}

// optional .Impinj.STP.Password secure_password = 3;
inline bool OrderedListEntry::has_secure_password() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void OrderedListEntry::set_has_secure_password() {
  _has_bits_[0] |= 0x00000004u;
}
inline void OrderedListEntry::clear_has_secure_password() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void OrderedListEntry::clear_secure_password() {
  if (secure_password_ != NULL) secure_password_->::Impinj::STP::Password::Clear();
  clear_has_secure_password();
}
inline const ::Impinj::STP::Password& OrderedListEntry::secure_password() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return secure_password_ != NULL ? *secure_password_ : *default_instance().secure_password_;
#else
  return secure_password_ != NULL ? *secure_password_ : *default_instance_->secure_password_;
#endif
}
inline ::Impinj::STP::Password* OrderedListEntry::mutable_secure_password() {
  set_has_secure_password();
  if (secure_password_ == NULL) secure_password_ = new ::Impinj::STP::Password;
  return secure_password_;
}
inline ::Impinj::STP::Password* OrderedListEntry::release_secure_password() {
  clear_has_secure_password();
  ::Impinj::STP::Password* temp = secure_password_;
  secure_password_ = NULL;
  return temp;
}
inline void OrderedListEntry::set_allocated_secure_password(::Impinj::STP::Password* secure_password) {
  delete secure_password_;
  secure_password_ = secure_password;
  if (secure_password) {
    set_has_secure_password();
  } else {
    clear_has_secure_password();
  }
}

// optional .Impinj.STP.Password access_password = 4;
inline bool OrderedListEntry::has_access_password() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void OrderedListEntry::set_has_access_password() {
  _has_bits_[0] |= 0x00000008u;
}
inline void OrderedListEntry::clear_has_access_password() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void OrderedListEntry::clear_access_password() {
  if (access_password_ != NULL) access_password_->::Impinj::STP::Password::Clear();
  clear_has_access_password();
}
inline const ::Impinj::STP::Password& OrderedListEntry::access_password() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return access_password_ != NULL ? *access_password_ : *default_instance().access_password_;
#else
  return access_password_ != NULL ? *access_password_ : *default_instance_->access_password_;
#endif
}
inline ::Impinj::STP::Password* OrderedListEntry::mutable_access_password() {
  set_has_access_password();
  if (access_password_ == NULL) access_password_ = new ::Impinj::STP::Password;
  return access_password_;
}
inline ::Impinj::STP::Password* OrderedListEntry::release_access_password() {
  clear_has_access_password();
  ::Impinj::STP::Password* temp = access_password_;
  access_password_ = NULL;
  return temp;
}
inline void OrderedListEntry::set_allocated_access_password(::Impinj::STP::Password* access_password) {
  delete access_password_;
  access_password_ = access_password;
  if (access_password) {
    set_has_access_password();
  } else {
    clear_has_access_password();
  }
}

// optional .Impinj.STP.Password kill_password = 5;
inline bool OrderedListEntry::has_kill_password() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void OrderedListEntry::set_has_kill_password() {
  _has_bits_[0] |= 0x00000010u;
}
inline void OrderedListEntry::clear_has_kill_password() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void OrderedListEntry::clear_kill_password() {
  if (kill_password_ != NULL) kill_password_->::Impinj::STP::Password::Clear();
  clear_has_kill_password();
}
inline const ::Impinj::STP::Password& OrderedListEntry::kill_password() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return kill_password_ != NULL ? *kill_password_ : *default_instance().kill_password_;
#else
  return kill_password_ != NULL ? *kill_password_ : *default_instance_->kill_password_;
#endif
}
inline ::Impinj::STP::Password* OrderedListEntry::mutable_kill_password() {
  set_has_kill_password();
  if (kill_password_ == NULL) kill_password_ = new ::Impinj::STP::Password;
  return kill_password_;
}
inline ::Impinj::STP::Password* OrderedListEntry::release_kill_password() {
  clear_has_kill_password();
  ::Impinj::STP::Password* temp = kill_password_;
  kill_password_ = NULL;
  return temp;
}
inline void OrderedListEntry::set_allocated_kill_password(::Impinj::STP::Password* kill_password) {
  delete kill_password_;
  kill_password_ = kill_password;
  if (kill_password) {
    set_has_kill_password();
  } else {
    clear_has_kill_password();
  }
}

// optional .Impinj.STP.LockConfig lock_config = 6;
inline bool OrderedListEntry::has_lock_config() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void OrderedListEntry::set_has_lock_config() {
  _has_bits_[0] |= 0x00000020u;
}
inline void OrderedListEntry::clear_has_lock_config() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void OrderedListEntry::clear_lock_config() {
  if (lock_config_ != NULL) lock_config_->::Impinj::STP::LockConfig::Clear();
  clear_has_lock_config();
}
inline const ::Impinj::STP::LockConfig& OrderedListEntry::lock_config() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return lock_config_ != NULL ? *lock_config_ : *default_instance().lock_config_;
#else
  return lock_config_ != NULL ? *lock_config_ : *default_instance_->lock_config_;
#endif
}
inline ::Impinj::STP::LockConfig* OrderedListEntry::mutable_lock_config() {
  set_has_lock_config();
  if (lock_config_ == NULL) lock_config_ = new ::Impinj::STP::LockConfig;
  return lock_config_;
}
inline ::Impinj::STP::LockConfig* OrderedListEntry::release_lock_config() {
  clear_has_lock_config();
  ::Impinj::STP::LockConfig* temp = lock_config_;
  lock_config_ = NULL;
  return temp;
}
inline void OrderedListEntry::set_allocated_lock_config(::Impinj::STP::LockConfig* lock_config) {
  delete lock_config_;
  lock_config_ = lock_config;
  if (lock_config) {
    set_has_lock_config();
  } else {
    clear_has_lock_config();
  }
}

// optional .Impinj.STP.BlockPermalockConfig blockpermalock_config = 7;
inline bool OrderedListEntry::has_blockpermalock_config() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void OrderedListEntry::set_has_blockpermalock_config() {
  _has_bits_[0] |= 0x00000040u;
}
inline void OrderedListEntry::clear_has_blockpermalock_config() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void OrderedListEntry::clear_blockpermalock_config() {
  if (blockpermalock_config_ != NULL) blockpermalock_config_->::Impinj::STP::BlockPermalockConfig::Clear();
  clear_has_blockpermalock_config();
}
inline const ::Impinj::STP::BlockPermalockConfig& OrderedListEntry::blockpermalock_config() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return blockpermalock_config_ != NULL ? *blockpermalock_config_ : *default_instance().blockpermalock_config_;
#else
  return blockpermalock_config_ != NULL ? *blockpermalock_config_ : *default_instance_->blockpermalock_config_;
#endif
}
inline ::Impinj::STP::BlockPermalockConfig* OrderedListEntry::mutable_blockpermalock_config() {
  set_has_blockpermalock_config();
  if (blockpermalock_config_ == NULL) blockpermalock_config_ = new ::Impinj::STP::BlockPermalockConfig;
  return blockpermalock_config_;
}
inline ::Impinj::STP::BlockPermalockConfig* OrderedListEntry::release_blockpermalock_config() {
  clear_has_blockpermalock_config();
  ::Impinj::STP::BlockPermalockConfig* temp = blockpermalock_config_;
  blockpermalock_config_ = NULL;
  return temp;
}
inline void OrderedListEntry::set_allocated_blockpermalock_config(::Impinj::STP::BlockPermalockConfig* blockpermalock_config) {
  delete blockpermalock_config_;
  blockpermalock_config_ = blockpermalock_config;
  if (blockpermalock_config) {
    set_has_blockpermalock_config();
  } else {
    clear_has_blockpermalock_config();
  }
}

// optional .Impinj.STP.TIDMemory TID_memory = 8;
inline bool OrderedListEntry::has_tid_memory() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void OrderedListEntry::set_has_tid_memory() {
  _has_bits_[0] |= 0x00000080u;
}
inline void OrderedListEntry::clear_has_tid_memory() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void OrderedListEntry::clear_tid_memory() {
  if (tid_memory_ != NULL) tid_memory_->::Impinj::STP::TIDMemory::Clear();
  clear_has_tid_memory();
}
inline const ::Impinj::STP::TIDMemory& OrderedListEntry::tid_memory() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return tid_memory_ != NULL ? *tid_memory_ : *default_instance().tid_memory_;
#else
  return tid_memory_ != NULL ? *tid_memory_ : *default_instance_->tid_memory_;
#endif
}
inline ::Impinj::STP::TIDMemory* OrderedListEntry::mutable_tid_memory() {
  set_has_tid_memory();
  if (tid_memory_ == NULL) tid_memory_ = new ::Impinj::STP::TIDMemory;
  return tid_memory_;
}
inline ::Impinj::STP::TIDMemory* OrderedListEntry::release_tid_memory() {
  clear_has_tid_memory();
  ::Impinj::STP::TIDMemory* temp = tid_memory_;
  tid_memory_ = NULL;
  return temp;
}
inline void OrderedListEntry::set_allocated_tid_memory(::Impinj::STP::TIDMemory* tid_memory) {
  delete tid_memory_;
  tid_memory_ = tid_memory;
  if (tid_memory) {
    set_has_tid_memory();
  } else {
    clear_has_tid_memory();
  }
}

// optional .Impinj.STP.MonzaR6PFeatureConfig monza_r6p_feature_config = 10;
inline bool OrderedListEntry::has_monza_r6p_feature_config() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void OrderedListEntry::set_has_monza_r6p_feature_config() {
  _has_bits_[0] |= 0x00000100u;
}
inline void OrderedListEntry::clear_has_monza_r6p_feature_config() {
  _has_bits_[0] &= ~0x00000100u;
}
inline void OrderedListEntry::clear_monza_r6p_feature_config() {
  if (monza_r6p_feature_config_ != NULL) monza_r6p_feature_config_->::Impinj::STP::MonzaR6PFeatureConfig::Clear();
  clear_has_monza_r6p_feature_config();
}
inline const ::Impinj::STP::MonzaR6PFeatureConfig& OrderedListEntry::monza_r6p_feature_config() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return monza_r6p_feature_config_ != NULL ? *monza_r6p_feature_config_ : *default_instance().monza_r6p_feature_config_;
#else
  return monza_r6p_feature_config_ != NULL ? *monza_r6p_feature_config_ : *default_instance_->monza_r6p_feature_config_;
#endif
}
inline ::Impinj::STP::MonzaR6PFeatureConfig* OrderedListEntry::mutable_monza_r6p_feature_config() {
  set_has_monza_r6p_feature_config();
  if (monza_r6p_feature_config_ == NULL) monza_r6p_feature_config_ = new ::Impinj::STP::MonzaR6PFeatureConfig;
  return monza_r6p_feature_config_;
}
inline ::Impinj::STP::MonzaR6PFeatureConfig* OrderedListEntry::release_monza_r6p_feature_config() {
  clear_has_monza_r6p_feature_config();
  ::Impinj::STP::MonzaR6PFeatureConfig* temp = monza_r6p_feature_config_;
  monza_r6p_feature_config_ = NULL;
  return temp;
}
inline void OrderedListEntry::set_allocated_monza_r6p_feature_config(::Impinj::STP::MonzaR6PFeatureConfig* monza_r6p_feature_config) {
  delete monza_r6p_feature_config_;
  monza_r6p_feature_config_ = monza_r6p_feature_config;
  if (monza_r6p_feature_config) {
    set_has_monza_r6p_feature_config();
  } else {
    clear_has_monza_r6p_feature_config();
  }
}

// optional .Impinj.STP.MonzaS6CFeatureConfig monza_s6c_feature_config = 11;
inline bool OrderedListEntry::has_monza_s6c_feature_config() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void OrderedListEntry::set_has_monza_s6c_feature_config() {
  _has_bits_[0] |= 0x00000200u;
}
inline void OrderedListEntry::clear_has_monza_s6c_feature_config() {
  _has_bits_[0] &= ~0x00000200u;
}
inline void OrderedListEntry::clear_monza_s6c_feature_config() {
  if (monza_s6c_feature_config_ != NULL) monza_s6c_feature_config_->::Impinj::STP::MonzaS6CFeatureConfig::Clear();
  clear_has_monza_s6c_feature_config();
}
inline const ::Impinj::STP::MonzaS6CFeatureConfig& OrderedListEntry::monza_s6c_feature_config() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return monza_s6c_feature_config_ != NULL ? *monza_s6c_feature_config_ : *default_instance().monza_s6c_feature_config_;
#else
  return monza_s6c_feature_config_ != NULL ? *monza_s6c_feature_config_ : *default_instance_->monza_s6c_feature_config_;
#endif
}
inline ::Impinj::STP::MonzaS6CFeatureConfig* OrderedListEntry::mutable_monza_s6c_feature_config() {
  set_has_monza_s6c_feature_config();
  if (monza_s6c_feature_config_ == NULL) monza_s6c_feature_config_ = new ::Impinj::STP::MonzaS6CFeatureConfig;
  return monza_s6c_feature_config_;
}
inline ::Impinj::STP::MonzaS6CFeatureConfig* OrderedListEntry::release_monza_s6c_feature_config() {
  clear_has_monza_s6c_feature_config();
  ::Impinj::STP::MonzaS6CFeatureConfig* temp = monza_s6c_feature_config_;
  monza_s6c_feature_config_ = NULL;
  return temp;
}
inline void OrderedListEntry::set_allocated_monza_s6c_feature_config(::Impinj::STP::MonzaS6CFeatureConfig* monza_s6c_feature_config) {
  delete monza_s6c_feature_config_;
  monza_s6c_feature_config_ = monza_s6c_feature_config;
  if (monza_s6c_feature_config) {
    set_has_monza_s6c_feature_config();
  } else {
    clear_has_monza_s6c_feature_config();
  }
}

// optional .Impinj.STP.MonzaR6FeatureConfig monza_r6_feature_config = 12;
inline bool OrderedListEntry::has_monza_r6_feature_config() const {
  return (_has_bits_[0] & 0x00000400u) != 0;
}
inline void OrderedListEntry::set_has_monza_r6_feature_config() {
  _has_bits_[0] |= 0x00000400u;
}
inline void OrderedListEntry::clear_has_monza_r6_feature_config() {
  _has_bits_[0] &= ~0x00000400u;
}
inline void OrderedListEntry::clear_monza_r6_feature_config() {
  if (monza_r6_feature_config_ != NULL) monza_r6_feature_config_->::Impinj::STP::MonzaR6FeatureConfig::Clear();
  clear_has_monza_r6_feature_config();
}
inline const ::Impinj::STP::MonzaR6FeatureConfig& OrderedListEntry::monza_r6_feature_config() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return monza_r6_feature_config_ != NULL ? *monza_r6_feature_config_ : *default_instance().monza_r6_feature_config_;
#else
  return monza_r6_feature_config_ != NULL ? *monza_r6_feature_config_ : *default_instance_->monza_r6_feature_config_;
#endif
}
inline ::Impinj::STP::MonzaR6FeatureConfig* OrderedListEntry::mutable_monza_r6_feature_config() {
  set_has_monza_r6_feature_config();
  if (monza_r6_feature_config_ == NULL) monza_r6_feature_config_ = new ::Impinj::STP::MonzaR6FeatureConfig;
  return monza_r6_feature_config_;
}
inline ::Impinj::STP::MonzaR6FeatureConfig* OrderedListEntry::release_monza_r6_feature_config() {
  clear_has_monza_r6_feature_config();
  ::Impinj::STP::MonzaR6FeatureConfig* temp = monza_r6_feature_config_;
  monza_r6_feature_config_ = NULL;
  return temp;
}
inline void OrderedListEntry::set_allocated_monza_r6_feature_config(::Impinj::STP::MonzaR6FeatureConfig* monza_r6_feature_config) {
  delete monza_r6_feature_config_;
  monza_r6_feature_config_ = monza_r6_feature_config;
  if (monza_r6_feature_config) {
    set_has_monza_r6_feature_config();
  } else {
    clear_has_monza_r6_feature_config();
  }
}

// optional .Impinj.STP.MonzaR6AFeatureConfig monza_r6a_feature_config = 13;
inline bool OrderedListEntry::has_monza_r6a_feature_config() const {
  return (_has_bits_[0] & 0x00000800u) != 0;
}
inline void OrderedListEntry::set_has_monza_r6a_feature_config() {
  _has_bits_[0] |= 0x00000800u;
}
inline void OrderedListEntry::clear_has_monza_r6a_feature_config() {
  _has_bits_[0] &= ~0x00000800u;
}
inline void OrderedListEntry::clear_monza_r6a_feature_config() {
  if (monza_r6a_feature_config_ != NULL) monza_r6a_feature_config_->::Impinj::STP::MonzaR6AFeatureConfig::Clear();
  clear_has_monza_r6a_feature_config();
}
inline const ::Impinj::STP::MonzaR6AFeatureConfig& OrderedListEntry::monza_r6a_feature_config() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return monza_r6a_feature_config_ != NULL ? *monza_r6a_feature_config_ : *default_instance().monza_r6a_feature_config_;
#else
  return monza_r6a_feature_config_ != NULL ? *monza_r6a_feature_config_ : *default_instance_->monza_r6a_feature_config_;
#endif
}
inline ::Impinj::STP::MonzaR6AFeatureConfig* OrderedListEntry::mutable_monza_r6a_feature_config() {
  set_has_monza_r6a_feature_config();
  if (monza_r6a_feature_config_ == NULL) monza_r6a_feature_config_ = new ::Impinj::STP::MonzaR6AFeatureConfig;
  return monza_r6a_feature_config_;
}
inline ::Impinj::STP::MonzaR6AFeatureConfig* OrderedListEntry::release_monza_r6a_feature_config() {
  clear_has_monza_r6a_feature_config();
  ::Impinj::STP::MonzaR6AFeatureConfig* temp = monza_r6a_feature_config_;
  monza_r6a_feature_config_ = NULL;
  return temp;
}
inline void OrderedListEntry::set_allocated_monza_r6a_feature_config(::Impinj::STP::MonzaR6AFeatureConfig* monza_r6a_feature_config) {
  delete monza_r6a_feature_config_;
  monza_r6a_feature_config_ = monza_r6a_feature_config;
  if (monza_r6a_feature_config) {
    set_has_monza_r6a_feature_config();
  } else {
    clear_has_monza_r6a_feature_config();
  }
}

// -------------------------------------------------------------------

// OrderedListEntries

// repeated .Impinj.STP.OrderedListEntry ordered_list_entries = 1;
inline int OrderedListEntries::ordered_list_entries_size() const {
  return ordered_list_entries_.size();
}
inline void OrderedListEntries::clear_ordered_list_entries() {
  ordered_list_entries_.Clear();
}
inline const ::Impinj::STP::OrderedListEntry& OrderedListEntries::ordered_list_entries(int index) const {
  return ordered_list_entries_.Get(index);
}
inline ::Impinj::STP::OrderedListEntry* OrderedListEntries::mutable_ordered_list_entries(int index) {
  return ordered_list_entries_.Mutable(index);
}
inline ::Impinj::STP::OrderedListEntry* OrderedListEntries::add_ordered_list_entries() {
  return ordered_list_entries_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::Impinj::STP::OrderedListEntry >&
OrderedListEntries::ordered_list_entries() const {
  return ordered_list_entries_;
}
inline ::google::protobuf::RepeatedPtrField< ::Impinj::STP::OrderedListEntry >*
OrderedListEntries::mutable_ordered_list_entries() {
  return &ordered_list_entries_;
}

// -------------------------------------------------------------------

// LowEncodeVolumeEventConfig

// optional bool enable_low_encode_volume_events = 1 [default = true];
inline bool LowEncodeVolumeEventConfig::has_enable_low_encode_volume_events() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void LowEncodeVolumeEventConfig::set_has_enable_low_encode_volume_events() {
  _has_bits_[0] |= 0x00000001u;
}
inline void LowEncodeVolumeEventConfig::clear_has_enable_low_encode_volume_events() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void LowEncodeVolumeEventConfig::clear_enable_low_encode_volume_events() {
  enable_low_encode_volume_events_ = true;
  clear_has_enable_low_encode_volume_events();
}
inline bool LowEncodeVolumeEventConfig::enable_low_encode_volume_events() const {
  return enable_low_encode_volume_events_;
}
inline void LowEncodeVolumeEventConfig::set_enable_low_encode_volume_events(bool value) {
  set_has_enable_low_encode_volume_events();
  enable_low_encode_volume_events_ = value;
}

// optional uint64 monza_threshold = 2 [default = 200000];
inline bool LowEncodeVolumeEventConfig::has_monza_threshold() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void LowEncodeVolumeEventConfig::set_has_monza_threshold() {
  _has_bits_[0] |= 0x00000002u;
}
inline void LowEncodeVolumeEventConfig::clear_has_monza_threshold() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void LowEncodeVolumeEventConfig::clear_monza_threshold() {
  monza_threshold_ = GOOGLE_ULONGLONG(200000);
  clear_has_monza_threshold();
}
inline ::google::protobuf::uint64 LowEncodeVolumeEventConfig::monza_threshold() const {
  return monza_threshold_;
}
inline void LowEncodeVolumeEventConfig::set_monza_threshold(::google::protobuf::uint64 value) {
  set_has_monza_threshold();
  monza_threshold_ = value;
}

// optional uint64 non_monza_threshold = 3 [default = 200000];
inline bool LowEncodeVolumeEventConfig::has_non_monza_threshold() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void LowEncodeVolumeEventConfig::set_has_non_monza_threshold() {
  _has_bits_[0] |= 0x00000004u;
}
inline void LowEncodeVolumeEventConfig::clear_has_non_monza_threshold() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void LowEncodeVolumeEventConfig::clear_non_monza_threshold() {
  non_monza_threshold_ = GOOGLE_ULONGLONG(200000);
  clear_has_non_monza_threshold();
}
inline ::google::protobuf::uint64 LowEncodeVolumeEventConfig::non_monza_threshold() const {
  return non_monza_threshold_;
}
inline void LowEncodeVolumeEventConfig::set_non_monza_threshold(::google::protobuf::uint64 value) {
  set_has_non_monza_threshold();
  non_monza_threshold_ = value;
}

// optional uint32 monza_reminder_period = 4 [default = 50000];
inline bool LowEncodeVolumeEventConfig::has_monza_reminder_period() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void LowEncodeVolumeEventConfig::set_has_monza_reminder_period() {
  _has_bits_[0] |= 0x00000008u;
}
inline void LowEncodeVolumeEventConfig::clear_has_monza_reminder_period() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void LowEncodeVolumeEventConfig::clear_monza_reminder_period() {
  monza_reminder_period_ = 50000u;
  clear_has_monza_reminder_period();
}
inline ::google::protobuf::uint32 LowEncodeVolumeEventConfig::monza_reminder_period() const {
  return monza_reminder_period_;
}
inline void LowEncodeVolumeEventConfig::set_monza_reminder_period(::google::protobuf::uint32 value) {
  set_has_monza_reminder_period();
  monza_reminder_period_ = value;
}

// optional uint32 non_monza_reminder_period = 5 [default = 50000];
inline bool LowEncodeVolumeEventConfig::has_non_monza_reminder_period() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void LowEncodeVolumeEventConfig::set_has_non_monza_reminder_period() {
  _has_bits_[0] |= 0x00000010u;
}
inline void LowEncodeVolumeEventConfig::clear_has_non_monza_reminder_period() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void LowEncodeVolumeEventConfig::clear_non_monza_reminder_period() {
  non_monza_reminder_period_ = 50000u;
  clear_has_non_monza_reminder_period();
}
inline ::google::protobuf::uint32 LowEncodeVolumeEventConfig::non_monza_reminder_period() const {
  return non_monza_reminder_period_;
}
inline void LowEncodeVolumeEventConfig::set_non_monza_reminder_period(::google::protobuf::uint32 value) {
  set_has_non_monza_reminder_period();
  non_monza_reminder_period_ = value;
}

// -------------------------------------------------------------------

// DeviceEventConfig

// optional bool enable_operation_events = 1 [default = true];
inline bool DeviceEventConfig::has_enable_operation_events() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void DeviceEventConfig::set_has_enable_operation_events() {
  _has_bits_[0] |= 0x00000001u;
}
inline void DeviceEventConfig::clear_has_enable_operation_events() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void DeviceEventConfig::clear_enable_operation_events() {
  enable_operation_events_ = true;
  clear_has_enable_operation_events();
}
inline bool DeviceEventConfig::enable_operation_events() const {
  return enable_operation_events_;
}
inline void DeviceEventConfig::set_enable_operation_events(bool value) {
  set_has_enable_operation_events();
  enable_operation_events_ = value;
}

// optional bool enable_GPI_events = 3 [default = false];
inline bool DeviceEventConfig::has_enable_gpi_events() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void DeviceEventConfig::set_has_enable_gpi_events() {
  _has_bits_[0] |= 0x00000002u;
}
inline void DeviceEventConfig::clear_has_enable_gpi_events() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void DeviceEventConfig::clear_enable_gpi_events() {
  enable_gpi_events_ = false;
  clear_has_enable_gpi_events();
}
inline bool DeviceEventConfig::enable_gpi_events() const {
  return enable_gpi_events_;
}
inline void DeviceEventConfig::set_enable_gpi_events(bool value) {
  set_has_enable_gpi_events();
  enable_gpi_events_ = value;
}

// optional .Impinj.STP.LowEncodeVolumeEventConfig low_encode_volume_event_config = 6;
inline bool DeviceEventConfig::has_low_encode_volume_event_config() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void DeviceEventConfig::set_has_low_encode_volume_event_config() {
  _has_bits_[0] |= 0x00000004u;
}
inline void DeviceEventConfig::clear_has_low_encode_volume_event_config() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void DeviceEventConfig::clear_low_encode_volume_event_config() {
  if (low_encode_volume_event_config_ != NULL) low_encode_volume_event_config_->::Impinj::STP::LowEncodeVolumeEventConfig::Clear();
  clear_has_low_encode_volume_event_config();
}
inline const ::Impinj::STP::LowEncodeVolumeEventConfig& DeviceEventConfig::low_encode_volume_event_config() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return low_encode_volume_event_config_ != NULL ? *low_encode_volume_event_config_ : *default_instance().low_encode_volume_event_config_;
#else
  return low_encode_volume_event_config_ != NULL ? *low_encode_volume_event_config_ : *default_instance_->low_encode_volume_event_config_;
#endif
}
inline ::Impinj::STP::LowEncodeVolumeEventConfig* DeviceEventConfig::mutable_low_encode_volume_event_config() {
  set_has_low_encode_volume_event_config();
  if (low_encode_volume_event_config_ == NULL) low_encode_volume_event_config_ = new ::Impinj::STP::LowEncodeVolumeEventConfig;
  return low_encode_volume_event_config_;
}
inline ::Impinj::STP::LowEncodeVolumeEventConfig* DeviceEventConfig::release_low_encode_volume_event_config() {
  clear_has_low_encode_volume_event_config();
  ::Impinj::STP::LowEncodeVolumeEventConfig* temp = low_encode_volume_event_config_;
  low_encode_volume_event_config_ = NULL;
  return temp;
}
inline void DeviceEventConfig::set_allocated_low_encode_volume_event_config(::Impinj::STP::LowEncodeVolumeEventConfig* low_encode_volume_event_config) {
  delete low_encode_volume_event_config_;
  low_encode_volume_event_config_ = low_encode_volume_event_config;
  if (low_encode_volume_event_config) {
    set_has_low_encode_volume_event_config();
  } else {
    clear_has_low_encode_volume_event_config();
  }
}

// -------------------------------------------------------------------

// OperationSummaryReport

// required .Impinj.STP.Timestamp timestamp = 1;
inline bool OperationSummaryReport::has_timestamp() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void OperationSummaryReport::set_has_timestamp() {
  _has_bits_[0] |= 0x00000001u;
}
inline void OperationSummaryReport::clear_has_timestamp() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void OperationSummaryReport::clear_timestamp() {
  if (timestamp_ != NULL) timestamp_->::Impinj::STP::Timestamp::Clear();
  clear_has_timestamp();
}
inline const ::Impinj::STP::Timestamp& OperationSummaryReport::timestamp() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return timestamp_ != NULL ? *timestamp_ : *default_instance().timestamp_;
#else
  return timestamp_ != NULL ? *timestamp_ : *default_instance_->timestamp_;
#endif
}
inline ::Impinj::STP::Timestamp* OperationSummaryReport::mutable_timestamp() {
  set_has_timestamp();
  if (timestamp_ == NULL) timestamp_ = new ::Impinj::STP::Timestamp;
  return timestamp_;
}
inline ::Impinj::STP::Timestamp* OperationSummaryReport::release_timestamp() {
  clear_has_timestamp();
  ::Impinj::STP::Timestamp* temp = timestamp_;
  timestamp_ = NULL;
  return temp;
}
inline void OperationSummaryReport::set_allocated_timestamp(::Impinj::STP::Timestamp* timestamp) {
  delete timestamp_;
  timestamp_ = timestamp;
  if (timestamp) {
    set_has_timestamp();
  } else {
    clear_has_timestamp();
  }
}

// required .Impinj.STP.OperationSummaryResult operation_result = 2;
inline bool OperationSummaryReport::has_operation_result() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void OperationSummaryReport::set_has_operation_result() {
  _has_bits_[0] |= 0x00000002u;
}
inline void OperationSummaryReport::clear_has_operation_result() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void OperationSummaryReport::clear_operation_result() {
  operation_result_ = 0;
  clear_has_operation_result();
}
inline ::Impinj::STP::OperationSummaryResult OperationSummaryReport::operation_result() const {
  return static_cast< ::Impinj::STP::OperationSummaryResult >(operation_result_);
}
inline void OperationSummaryReport::set_operation_result(::Impinj::STP::OperationSummaryResult value) {
  assert(::Impinj::STP::OperationSummaryResult_IsValid(value));
  set_has_operation_result();
  operation_result_ = value;
}

// optional string operation_result_detail = 3;
inline bool OperationSummaryReport::has_operation_result_detail() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void OperationSummaryReport::set_has_operation_result_detail() {
  _has_bits_[0] |= 0x00000004u;
}
inline void OperationSummaryReport::clear_has_operation_result_detail() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void OperationSummaryReport::clear_operation_result_detail() {
  if (operation_result_detail_ != &::google::protobuf::internal::kEmptyString) {
    operation_result_detail_->clear();
  }
  clear_has_operation_result_detail();
}
inline const ::std::string& OperationSummaryReport::operation_result_detail() const {
  return *operation_result_detail_;
}
inline void OperationSummaryReport::set_operation_result_detail(const ::std::string& value) {
  set_has_operation_result_detail();
  if (operation_result_detail_ == &::google::protobuf::internal::kEmptyString) {
    operation_result_detail_ = new ::std::string;
  }
  operation_result_detail_->assign(value);
}
inline void OperationSummaryReport::set_operation_result_detail(const char* value) {
  set_has_operation_result_detail();
  if (operation_result_detail_ == &::google::protobuf::internal::kEmptyString) {
    operation_result_detail_ = new ::std::string;
  }
  operation_result_detail_->assign(value);
}
inline void OperationSummaryReport::set_operation_result_detail(const char* value, size_t size) {
  set_has_operation_result_detail();
  if (operation_result_detail_ == &::google::protobuf::internal::kEmptyString) {
    operation_result_detail_ = new ::std::string;
  }
  operation_result_detail_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* OperationSummaryReport::mutable_operation_result_detail() {
  set_has_operation_result_detail();
  if (operation_result_detail_ == &::google::protobuf::internal::kEmptyString) {
    operation_result_detail_ = new ::std::string;
  }
  return operation_result_detail_;
}
inline ::std::string* OperationSummaryReport::release_operation_result_detail() {
  clear_has_operation_result_detail();
  if (operation_result_detail_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = operation_result_detail_;
    operation_result_detail_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void OperationSummaryReport::set_allocated_operation_result_detail(::std::string* operation_result_detail) {
  if (operation_result_detail_ != &::google::protobuf::internal::kEmptyString) {
    delete operation_result_detail_;
  }
  if (operation_result_detail) {
    set_has_operation_result_detail();
    operation_result_detail_ = operation_result_detail;
  } else {
    clear_has_operation_result_detail();
    operation_result_detail_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional uint32 operation_elapsed_time = 4;
inline bool OperationSummaryReport::has_operation_elapsed_time() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void OperationSummaryReport::set_has_operation_elapsed_time() {
  _has_bits_[0] |= 0x00000008u;
}
inline void OperationSummaryReport::clear_has_operation_elapsed_time() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void OperationSummaryReport::clear_operation_elapsed_time() {
  operation_elapsed_time_ = 0u;
  clear_has_operation_elapsed_time();
}
inline ::google::protobuf::uint32 OperationSummaryReport::operation_elapsed_time() const {
  return operation_elapsed_time_;
}
inline void OperationSummaryReport::set_operation_elapsed_time(::google::protobuf::uint32 value) {
  set_has_operation_elapsed_time();
  operation_elapsed_time_ = value;
}

// optional uint32 tag_operation_total_count = 5;
inline bool OperationSummaryReport::has_tag_operation_total_count() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void OperationSummaryReport::set_has_tag_operation_total_count() {
  _has_bits_[0] |= 0x00000010u;
}
inline void OperationSummaryReport::clear_has_tag_operation_total_count() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void OperationSummaryReport::clear_tag_operation_total_count() {
  tag_operation_total_count_ = 0u;
  clear_has_tag_operation_total_count();
}
inline ::google::protobuf::uint32 OperationSummaryReport::tag_operation_total_count() const {
  return tag_operation_total_count_;
}
inline void OperationSummaryReport::set_tag_operation_total_count(::google::protobuf::uint32 value) {
  set_has_tag_operation_total_count();
  tag_operation_total_count_ = value;
}

// optional uint32 tag_operation_pass_count = 6;
inline bool OperationSummaryReport::has_tag_operation_pass_count() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void OperationSummaryReport::set_has_tag_operation_pass_count() {
  _has_bits_[0] |= 0x00000020u;
}
inline void OperationSummaryReport::clear_has_tag_operation_pass_count() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void OperationSummaryReport::clear_tag_operation_pass_count() {
  tag_operation_pass_count_ = 0u;
  clear_has_tag_operation_pass_count();
}
inline ::google::protobuf::uint32 OperationSummaryReport::tag_operation_pass_count() const {
  return tag_operation_pass_count_;
}
inline void OperationSummaryReport::set_tag_operation_pass_count(::google::protobuf::uint32 value) {
  set_has_tag_operation_pass_count();
  tag_operation_pass_count_ = value;
}

// optional uint32 tag_operation_fail_count = 7;
inline bool OperationSummaryReport::has_tag_operation_fail_count() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void OperationSummaryReport::set_has_tag_operation_fail_count() {
  _has_bits_[0] |= 0x00000040u;
}
inline void OperationSummaryReport::clear_has_tag_operation_fail_count() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void OperationSummaryReport::clear_tag_operation_fail_count() {
  tag_operation_fail_count_ = 0u;
  clear_has_tag_operation_fail_count();
}
inline ::google::protobuf::uint32 OperationSummaryReport::tag_operation_fail_count() const {
  return tag_operation_fail_count_;
}
inline void OperationSummaryReport::set_tag_operation_fail_count(::google::protobuf::uint32 value) {
  set_has_tag_operation_fail_count();
  tag_operation_fail_count_ = value;
}

// -------------------------------------------------------------------

// TagOperationReport

// required .Impinj.STP.TagOperationReportType tag_operation_report_type = 1;
inline bool TagOperationReport::has_tag_operation_report_type() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TagOperationReport::set_has_tag_operation_report_type() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TagOperationReport::clear_has_tag_operation_report_type() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TagOperationReport::clear_tag_operation_report_type() {
  tag_operation_report_type_ = 0;
  clear_has_tag_operation_report_type();
}
inline ::Impinj::STP::TagOperationReportType TagOperationReport::tag_operation_report_type() const {
  return static_cast< ::Impinj::STP::TagOperationReportType >(tag_operation_report_type_);
}
inline void TagOperationReport::set_tag_operation_report_type(::Impinj::STP::TagOperationReportType value) {
  assert(::Impinj::STP::TagOperationReportType_IsValid(value));
  set_has_tag_operation_report_type();
  tag_operation_report_type_ = value;
}

// optional .Impinj.STP.TagOperationResult tag_operation_result = 2;
inline bool TagOperationReport::has_tag_operation_result() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void TagOperationReport::set_has_tag_operation_result() {
  _has_bits_[0] |= 0x00000002u;
}
inline void TagOperationReport::clear_has_tag_operation_result() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void TagOperationReport::clear_tag_operation_result() {
  tag_operation_result_ = 0;
  clear_has_tag_operation_result();
}
inline ::Impinj::STP::TagOperationResult TagOperationReport::tag_operation_result() const {
  return static_cast< ::Impinj::STP::TagOperationResult >(tag_operation_result_);
}
inline void TagOperationReport::set_tag_operation_result(::Impinj::STP::TagOperationResult value) {
  assert(::Impinj::STP::TagOperationResult_IsValid(value));
  set_has_tag_operation_result();
  tag_operation_result_ = value;
}

// optional string tag_operation_result_detail = 3;
inline bool TagOperationReport::has_tag_operation_result_detail() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void TagOperationReport::set_has_tag_operation_result_detail() {
  _has_bits_[0] |= 0x00000004u;
}
inline void TagOperationReport::clear_has_tag_operation_result_detail() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void TagOperationReport::clear_tag_operation_result_detail() {
  if (tag_operation_result_detail_ != &::google::protobuf::internal::kEmptyString) {
    tag_operation_result_detail_->clear();
  }
  clear_has_tag_operation_result_detail();
}
inline const ::std::string& TagOperationReport::tag_operation_result_detail() const {
  return *tag_operation_result_detail_;
}
inline void TagOperationReport::set_tag_operation_result_detail(const ::std::string& value) {
  set_has_tag_operation_result_detail();
  if (tag_operation_result_detail_ == &::google::protobuf::internal::kEmptyString) {
    tag_operation_result_detail_ = new ::std::string;
  }
  tag_operation_result_detail_->assign(value);
}
inline void TagOperationReport::set_tag_operation_result_detail(const char* value) {
  set_has_tag_operation_result_detail();
  if (tag_operation_result_detail_ == &::google::protobuf::internal::kEmptyString) {
    tag_operation_result_detail_ = new ::std::string;
  }
  tag_operation_result_detail_->assign(value);
}
inline void TagOperationReport::set_tag_operation_result_detail(const char* value, size_t size) {
  set_has_tag_operation_result_detail();
  if (tag_operation_result_detail_ == &::google::protobuf::internal::kEmptyString) {
    tag_operation_result_detail_ = new ::std::string;
  }
  tag_operation_result_detail_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* TagOperationReport::mutable_tag_operation_result_detail() {
  set_has_tag_operation_result_detail();
  if (tag_operation_result_detail_ == &::google::protobuf::internal::kEmptyString) {
    tag_operation_result_detail_ = new ::std::string;
  }
  return tag_operation_result_detail_;
}
inline ::std::string* TagOperationReport::release_tag_operation_result_detail() {
  clear_has_tag_operation_result_detail();
  if (tag_operation_result_detail_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = tag_operation_result_detail_;
    tag_operation_result_detail_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void TagOperationReport::set_allocated_tag_operation_result_detail(::std::string* tag_operation_result_detail) {
  if (tag_operation_result_detail_ != &::google::protobuf::internal::kEmptyString) {
    delete tag_operation_result_detail_;
  }
  if (tag_operation_result_detail) {
    set_has_tag_operation_result_detail();
    tag_operation_result_detail_ = tag_operation_result_detail;
  } else {
    clear_has_tag_operation_result_detail();
    tag_operation_result_detail_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional bytes TID = 4;
inline bool TagOperationReport::has_tid() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void TagOperationReport::set_has_tid() {
  _has_bits_[0] |= 0x00000008u;
}
inline void TagOperationReport::clear_has_tid() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void TagOperationReport::clear_tid() {
  if (tid_ != &::google::protobuf::internal::kEmptyString) {
    tid_->clear();
  }
  clear_has_tid();
}
inline const ::std::string& TagOperationReport::tid() const {
  return *tid_;
}
inline void TagOperationReport::set_tid(const ::std::string& value) {
  set_has_tid();
  if (tid_ == &::google::protobuf::internal::kEmptyString) {
    tid_ = new ::std::string;
  }
  tid_->assign(value);
}
inline void TagOperationReport::set_tid(const char* value) {
  set_has_tid();
  if (tid_ == &::google::protobuf::internal::kEmptyString) {
    tid_ = new ::std::string;
  }
  tid_->assign(value);
}
inline void TagOperationReport::set_tid(const void* value, size_t size) {
  set_has_tid();
  if (tid_ == &::google::protobuf::internal::kEmptyString) {
    tid_ = new ::std::string;
  }
  tid_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* TagOperationReport::mutable_tid() {
  set_has_tid();
  if (tid_ == &::google::protobuf::internal::kEmptyString) {
    tid_ = new ::std::string;
  }
  return tid_;
}
inline ::std::string* TagOperationReport::release_tid() {
  clear_has_tid();
  if (tid_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = tid_;
    tid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void TagOperationReport::set_allocated_tid(::std::string* tid) {
  if (tid_ != &::google::protobuf::internal::kEmptyString) {
    delete tid_;
  }
  if (tid) {
    set_has_tid();
    tid_ = tid;
  } else {
    clear_has_tid();
    tid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional bytes EPC = 5;
inline bool TagOperationReport::has_epc() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void TagOperationReport::set_has_epc() {
  _has_bits_[0] |= 0x00000010u;
}
inline void TagOperationReport::clear_has_epc() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void TagOperationReport::clear_epc() {
  if (epc_ != &::google::protobuf::internal::kEmptyString) {
    epc_->clear();
  }
  clear_has_epc();
}
inline const ::std::string& TagOperationReport::epc() const {
  return *epc_;
}
inline void TagOperationReport::set_epc(const ::std::string& value) {
  set_has_epc();
  if (epc_ == &::google::protobuf::internal::kEmptyString) {
    epc_ = new ::std::string;
  }
  epc_->assign(value);
}
inline void TagOperationReport::set_epc(const char* value) {
  set_has_epc();
  if (epc_ == &::google::protobuf::internal::kEmptyString) {
    epc_ = new ::std::string;
  }
  epc_->assign(value);
}
inline void TagOperationReport::set_epc(const void* value, size_t size) {
  set_has_epc();
  if (epc_ == &::google::protobuf::internal::kEmptyString) {
    epc_ = new ::std::string;
  }
  epc_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* TagOperationReport::mutable_epc() {
  set_has_epc();
  if (epc_ == &::google::protobuf::internal::kEmptyString) {
    epc_ = new ::std::string;
  }
  return epc_;
}
inline ::std::string* TagOperationReport::release_epc() {
  clear_has_epc();
  if (epc_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = epc_;
    epc_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void TagOperationReport::set_allocated_epc(::std::string* epc) {
  if (epc_ != &::google::protobuf::internal::kEmptyString) {
    delete epc_;
  }
  if (epc) {
    set_has_epc();
    epc_ = epc;
  } else {
    clear_has_epc();
    epc_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional bytes EPC_attempted = 6;
inline bool TagOperationReport::has_epc_attempted() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void TagOperationReport::set_has_epc_attempted() {
  _has_bits_[0] |= 0x00000020u;
}
inline void TagOperationReport::clear_has_epc_attempted() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void TagOperationReport::clear_epc_attempted() {
  if (epc_attempted_ != &::google::protobuf::internal::kEmptyString) {
    epc_attempted_->clear();
  }
  clear_has_epc_attempted();
}
inline const ::std::string& TagOperationReport::epc_attempted() const {
  return *epc_attempted_;
}
inline void TagOperationReport::set_epc_attempted(const ::std::string& value) {
  set_has_epc_attempted();
  if (epc_attempted_ == &::google::protobuf::internal::kEmptyString) {
    epc_attempted_ = new ::std::string;
  }
  epc_attempted_->assign(value);
}
inline void TagOperationReport::set_epc_attempted(const char* value) {
  set_has_epc_attempted();
  if (epc_attempted_ == &::google::protobuf::internal::kEmptyString) {
    epc_attempted_ = new ::std::string;
  }
  epc_attempted_->assign(value);
}
inline void TagOperationReport::set_epc_attempted(const void* value, size_t size) {
  set_has_epc_attempted();
  if (epc_attempted_ == &::google::protobuf::internal::kEmptyString) {
    epc_attempted_ = new ::std::string;
  }
  epc_attempted_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* TagOperationReport::mutable_epc_attempted() {
  set_has_epc_attempted();
  if (epc_attempted_ == &::google::protobuf::internal::kEmptyString) {
    epc_attempted_ = new ::std::string;
  }
  return epc_attempted_;
}
inline ::std::string* TagOperationReport::release_epc_attempted() {
  clear_has_epc_attempted();
  if (epc_attempted_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = epc_attempted_;
    epc_attempted_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void TagOperationReport::set_allocated_epc_attempted(::std::string* epc_attempted) {
  if (epc_attempted_ != &::google::protobuf::internal::kEmptyString) {
    delete epc_attempted_;
  }
  if (epc_attempted) {
    set_has_epc_attempted();
    epc_attempted_ = epc_attempted;
  } else {
    clear_has_epc_attempted();
    epc_attempted_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional bytes user_memory_inv = 19;
inline bool TagOperationReport::has_user_memory_inv() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void TagOperationReport::set_has_user_memory_inv() {
  _has_bits_[0] |= 0x00000040u;
}
inline void TagOperationReport::clear_has_user_memory_inv() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void TagOperationReport::clear_user_memory_inv() {
  if (user_memory_inv_ != &::google::protobuf::internal::kEmptyString) {
    user_memory_inv_->clear();
  }
  clear_has_user_memory_inv();
}
inline const ::std::string& TagOperationReport::user_memory_inv() const {
  return *user_memory_inv_;
}
inline void TagOperationReport::set_user_memory_inv(const ::std::string& value) {
  set_has_user_memory_inv();
  if (user_memory_inv_ == &::google::protobuf::internal::kEmptyString) {
    user_memory_inv_ = new ::std::string;
  }
  user_memory_inv_->assign(value);
}
inline void TagOperationReport::set_user_memory_inv(const char* value) {
  set_has_user_memory_inv();
  if (user_memory_inv_ == &::google::protobuf::internal::kEmptyString) {
    user_memory_inv_ = new ::std::string;
  }
  user_memory_inv_->assign(value);
}
inline void TagOperationReport::set_user_memory_inv(const void* value, size_t size) {
  set_has_user_memory_inv();
  if (user_memory_inv_ == &::google::protobuf::internal::kEmptyString) {
    user_memory_inv_ = new ::std::string;
  }
  user_memory_inv_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* TagOperationReport::mutable_user_memory_inv() {
  set_has_user_memory_inv();
  if (user_memory_inv_ == &::google::protobuf::internal::kEmptyString) {
    user_memory_inv_ = new ::std::string;
  }
  return user_memory_inv_;
}
inline ::std::string* TagOperationReport::release_user_memory_inv() {
  clear_has_user_memory_inv();
  if (user_memory_inv_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = user_memory_inv_;
    user_memory_inv_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void TagOperationReport::set_allocated_user_memory_inv(::std::string* user_memory_inv) {
  if (user_memory_inv_ != &::google::protobuf::internal::kEmptyString) {
    delete user_memory_inv_;
  }
  if (user_memory_inv) {
    set_has_user_memory_inv();
    user_memory_inv_ = user_memory_inv;
  } else {
    clear_has_user_memory_inv();
    user_memory_inv_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional bool EPC_memory_result = 7;
inline bool TagOperationReport::has_epc_memory_result() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void TagOperationReport::set_has_epc_memory_result() {
  _has_bits_[0] |= 0x00000080u;
}
inline void TagOperationReport::clear_has_epc_memory_result() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void TagOperationReport::clear_epc_memory_result() {
  epc_memory_result_ = false;
  clear_has_epc_memory_result();
}
inline bool TagOperationReport::epc_memory_result() const {
  return epc_memory_result_;
}
inline void TagOperationReport::set_epc_memory_result(bool value) {
  set_has_epc_memory_result();
  epc_memory_result_ = value;
}

// optional bool access_password_result = 8;
inline bool TagOperationReport::has_access_password_result() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void TagOperationReport::set_has_access_password_result() {
  _has_bits_[0] |= 0x00000100u;
}
inline void TagOperationReport::clear_has_access_password_result() {
  _has_bits_[0] &= ~0x00000100u;
}
inline void TagOperationReport::clear_access_password_result() {
  access_password_result_ = false;
  clear_has_access_password_result();
}
inline bool TagOperationReport::access_password_result() const {
  return access_password_result_;
}
inline void TagOperationReport::set_access_password_result(bool value) {
  set_has_access_password_result();
  access_password_result_ = value;
}

// optional bool kill_password_result = 9;
inline bool TagOperationReport::has_kill_password_result() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void TagOperationReport::set_has_kill_password_result() {
  _has_bits_[0] |= 0x00000200u;
}
inline void TagOperationReport::clear_has_kill_password_result() {
  _has_bits_[0] &= ~0x00000200u;
}
inline void TagOperationReport::clear_kill_password_result() {
  kill_password_result_ = false;
  clear_has_kill_password_result();
}
inline bool TagOperationReport::kill_password_result() const {
  return kill_password_result_;
}
inline void TagOperationReport::set_kill_password_result(bool value) {
  set_has_kill_password_result();
  kill_password_result_ = value;
}

// optional bool lock_config_result = 10;
inline bool TagOperationReport::has_lock_config_result() const {
  return (_has_bits_[0] & 0x00000400u) != 0;
}
inline void TagOperationReport::set_has_lock_config_result() {
  _has_bits_[0] |= 0x00000400u;
}
inline void TagOperationReport::clear_has_lock_config_result() {
  _has_bits_[0] &= ~0x00000400u;
}
inline void TagOperationReport::clear_lock_config_result() {
  lock_config_result_ = false;
  clear_has_lock_config_result();
}
inline bool TagOperationReport::lock_config_result() const {
  return lock_config_result_;
}
inline void TagOperationReport::set_lock_config_result(bool value) {
  set_has_lock_config_result();
  lock_config_result_ = value;
}

// optional bool user_memory_result = 11;
inline bool TagOperationReport::has_user_memory_result() const {
  return (_has_bits_[0] & 0x00000800u) != 0;
}
inline void TagOperationReport::set_has_user_memory_result() {
  _has_bits_[0] |= 0x00000800u;
}
inline void TagOperationReport::clear_has_user_memory_result() {
  _has_bits_[0] &= ~0x00000800u;
}
inline void TagOperationReport::clear_user_memory_result() {
  user_memory_result_ = false;
  clear_has_user_memory_result();
}
inline bool TagOperationReport::user_memory_result() const {
  return user_memory_result_;
}
inline void TagOperationReport::set_user_memory_result(bool value) {
  set_has_user_memory_result();
  user_memory_result_ = value;
}

// optional bool blockpermalock_result = 12;
inline bool TagOperationReport::has_blockpermalock_result() const {
  return (_has_bits_[0] & 0x00001000u) != 0;
}
inline void TagOperationReport::set_has_blockpermalock_result() {
  _has_bits_[0] |= 0x00001000u;
}
inline void TagOperationReport::clear_has_blockpermalock_result() {
  _has_bits_[0] &= ~0x00001000u;
}
inline void TagOperationReport::clear_blockpermalock_result() {
  blockpermalock_result_ = false;
  clear_has_blockpermalock_result();
}
inline bool TagOperationReport::blockpermalock_result() const {
  return blockpermalock_result_;
}
inline void TagOperationReport::set_blockpermalock_result(bool value) {
  set_has_blockpermalock_result();
  blockpermalock_result_ = value;
}

// optional bool kill_tag_result = 18;
inline bool TagOperationReport::has_kill_tag_result() const {
  return (_has_bits_[0] & 0x00002000u) != 0;
}
inline void TagOperationReport::set_has_kill_tag_result() {
  _has_bits_[0] |= 0x00002000u;
}
inline void TagOperationReport::clear_has_kill_tag_result() {
  _has_bits_[0] &= ~0x00002000u;
}
inline void TagOperationReport::clear_kill_tag_result() {
  kill_tag_result_ = false;
  clear_has_kill_tag_result();
}
inline bool TagOperationReport::kill_tag_result() const {
  return kill_tag_result_;
}
inline void TagOperationReport::set_kill_tag_result(bool value) {
  set_has_kill_tag_result();
  kill_tag_result_ = value;
}

// optional bool pc_word_result = 20;
inline bool TagOperationReport::has_pc_word_result() const {
  return (_has_bits_[0] & 0x00004000u) != 0;
}
inline void TagOperationReport::set_has_pc_word_result() {
  _has_bits_[0] |= 0x00004000u;
}
inline void TagOperationReport::clear_has_pc_word_result() {
  _has_bits_[0] &= ~0x00004000u;
}
inline void TagOperationReport::clear_pc_word_result() {
  pc_word_result_ = false;
  clear_has_pc_word_result();
}
inline bool TagOperationReport::pc_word_result() const {
  return pc_word_result_;
}
inline void TagOperationReport::set_pc_word_result(bool value) {
  set_has_pc_word_result();
  pc_word_result_ = value;
}

// optional bool tag_specific_feature_config_result = 21;
inline bool TagOperationReport::has_tag_specific_feature_config_result() const {
  return (_has_bits_[0] & 0x00008000u) != 0;
}
inline void TagOperationReport::set_has_tag_specific_feature_config_result() {
  _has_bits_[0] |= 0x00008000u;
}
inline void TagOperationReport::clear_has_tag_specific_feature_config_result() {
  _has_bits_[0] &= ~0x00008000u;
}
inline void TagOperationReport::clear_tag_specific_feature_config_result() {
  tag_specific_feature_config_result_ = false;
  clear_has_tag_specific_feature_config_result();
}
inline bool TagOperationReport::tag_specific_feature_config_result() const {
  return tag_specific_feature_config_result_;
}
inline void TagOperationReport::set_tag_specific_feature_config_result(bool value) {
  set_has_tag_specific_feature_config_result();
  tag_specific_feature_config_result_ = value;
}

// optional bool tid_write_result = 22;
inline bool TagOperationReport::has_tid_write_result() const {
  return (_has_bits_[0] & 0x00010000u) != 0;
}
inline void TagOperationReport::set_has_tid_write_result() {
  _has_bits_[0] |= 0x00010000u;
}
inline void TagOperationReport::clear_has_tid_write_result() {
  _has_bits_[0] &= ~0x00010000u;
}
inline void TagOperationReport::clear_tid_write_result() {
  tid_write_result_ = false;
  clear_has_tid_write_result();
}
inline bool TagOperationReport::tid_write_result() const {
  return tid_write_result_;
}
inline void TagOperationReport::set_tid_write_result(bool value) {
  set_has_tid_write_result();
  tid_write_result_ = value;
}

// optional .Impinj.STP.Timestamp timestamp = 13;
inline bool TagOperationReport::has_timestamp() const {
  return (_has_bits_[0] & 0x00020000u) != 0;
}
inline void TagOperationReport::set_has_timestamp() {
  _has_bits_[0] |= 0x00020000u;
}
inline void TagOperationReport::clear_has_timestamp() {
  _has_bits_[0] &= ~0x00020000u;
}
inline void TagOperationReport::clear_timestamp() {
  if (timestamp_ != NULL) timestamp_->::Impinj::STP::Timestamp::Clear();
  clear_has_timestamp();
}
inline const ::Impinj::STP::Timestamp& TagOperationReport::timestamp() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return timestamp_ != NULL ? *timestamp_ : *default_instance().timestamp_;
#else
  return timestamp_ != NULL ? *timestamp_ : *default_instance_->timestamp_;
#endif
}
inline ::Impinj::STP::Timestamp* TagOperationReport::mutable_timestamp() {
  set_has_timestamp();
  if (timestamp_ == NULL) timestamp_ = new ::Impinj::STP::Timestamp;
  return timestamp_;
}
inline ::Impinj::STP::Timestamp* TagOperationReport::release_timestamp() {
  clear_has_timestamp();
  ::Impinj::STP::Timestamp* temp = timestamp_;
  timestamp_ = NULL;
  return temp;
}
inline void TagOperationReport::set_allocated_timestamp(::Impinj::STP::Timestamp* timestamp) {
  delete timestamp_;
  timestamp_ = timestamp;
  if (timestamp) {
    set_has_timestamp();
  } else {
    clear_has_timestamp();
  }
}

// optional uint32 antenna_ID = 14;
inline bool TagOperationReport::has_antenna_id() const {
  return (_has_bits_[0] & 0x00040000u) != 0;
}
inline void TagOperationReport::set_has_antenna_id() {
  _has_bits_[0] |= 0x00040000u;
}
inline void TagOperationReport::clear_has_antenna_id() {
  _has_bits_[0] &= ~0x00040000u;
}
inline void TagOperationReport::clear_antenna_id() {
  antenna_id_ = 0u;
  clear_has_antenna_id();
}
inline ::google::protobuf::uint32 TagOperationReport::antenna_id() const {
  return antenna_id_;
}
inline void TagOperationReport::set_antenna_id(::google::protobuf::uint32 value) {
  set_has_antenna_id();
  antenna_id_ = value;
}

// optional uint32 frequency = 15;
inline bool TagOperationReport::has_frequency() const {
  return (_has_bits_[0] & 0x00080000u) != 0;
}
inline void TagOperationReport::set_has_frequency() {
  _has_bits_[0] |= 0x00080000u;
}
inline void TagOperationReport::clear_has_frequency() {
  _has_bits_[0] &= ~0x00080000u;
}
inline void TagOperationReport::clear_frequency() {
  frequency_ = 0u;
  clear_has_frequency();
}
inline ::google::protobuf::uint32 TagOperationReport::frequency() const {
  return frequency_;
}
inline void TagOperationReport::set_frequency(::google::protobuf::uint32 value) {
  set_has_frequency();
  frequency_ = value;
}

// optional sint32 RSSI = 16;
inline bool TagOperationReport::has_rssi() const {
  return (_has_bits_[0] & 0x00100000u) != 0;
}
inline void TagOperationReport::set_has_rssi() {
  _has_bits_[0] |= 0x00100000u;
}
inline void TagOperationReport::clear_has_rssi() {
  _has_bits_[0] &= ~0x00100000u;
}
inline void TagOperationReport::clear_rssi() {
  rssi_ = 0;
  clear_has_rssi();
}
inline ::google::protobuf::int32 TagOperationReport::rssi() const {
  return rssi_;
}
inline void TagOperationReport::set_rssi(::google::protobuf::int32 value) {
  set_has_rssi();
  rssi_ = value;
}

// optional uint32 job_id = 17;
inline bool TagOperationReport::has_job_id() const {
  return (_has_bits_[0] & 0x00200000u) != 0;
}
inline void TagOperationReport::set_has_job_id() {
  _has_bits_[0] |= 0x00200000u;
}
inline void TagOperationReport::clear_has_job_id() {
  _has_bits_[0] &= ~0x00200000u;
}
inline void TagOperationReport::clear_job_id() {
  job_id_ = 0u;
  clear_has_job_id();
}
inline ::google::protobuf::uint32 TagOperationReport::job_id() const {
  return job_id_;
}
inline void TagOperationReport::set_job_id(::google::protobuf::uint32 value) {
  set_has_job_id();
  job_id_ = value;
}

// -------------------------------------------------------------------

// CartonContentsTag

// optional bytes tid = 1;
inline bool CartonContentsTag::has_tid() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CartonContentsTag::set_has_tid() {
  _has_bits_[0] |= 0x00000001u;
}
inline void CartonContentsTag::clear_has_tid() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void CartonContentsTag::clear_tid() {
  if (tid_ != &::google::protobuf::internal::kEmptyString) {
    tid_->clear();
  }
  clear_has_tid();
}
inline const ::std::string& CartonContentsTag::tid() const {
  return *tid_;
}
inline void CartonContentsTag::set_tid(const ::std::string& value) {
  set_has_tid();
  if (tid_ == &::google::protobuf::internal::kEmptyString) {
    tid_ = new ::std::string;
  }
  tid_->assign(value);
}
inline void CartonContentsTag::set_tid(const char* value) {
  set_has_tid();
  if (tid_ == &::google::protobuf::internal::kEmptyString) {
    tid_ = new ::std::string;
  }
  tid_->assign(value);
}
inline void CartonContentsTag::set_tid(const void* value, size_t size) {
  set_has_tid();
  if (tid_ == &::google::protobuf::internal::kEmptyString) {
    tid_ = new ::std::string;
  }
  tid_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* CartonContentsTag::mutable_tid() {
  set_has_tid();
  if (tid_ == &::google::protobuf::internal::kEmptyString) {
    tid_ = new ::std::string;
  }
  return tid_;
}
inline ::std::string* CartonContentsTag::release_tid() {
  clear_has_tid();
  if (tid_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = tid_;
    tid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void CartonContentsTag::set_allocated_tid(::std::string* tid) {
  if (tid_ != &::google::protobuf::internal::kEmptyString) {
    delete tid_;
  }
  if (tid) {
    set_has_tid();
    tid_ = tid;
  } else {
    clear_has_tid();
    tid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional bytes epc = 2;
inline bool CartonContentsTag::has_epc() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void CartonContentsTag::set_has_epc() {
  _has_bits_[0] |= 0x00000002u;
}
inline void CartonContentsTag::clear_has_epc() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void CartonContentsTag::clear_epc() {
  if (epc_ != &::google::protobuf::internal::kEmptyString) {
    epc_->clear();
  }
  clear_has_epc();
}
inline const ::std::string& CartonContentsTag::epc() const {
  return *epc_;
}
inline void CartonContentsTag::set_epc(const ::std::string& value) {
  set_has_epc();
  if (epc_ == &::google::protobuf::internal::kEmptyString) {
    epc_ = new ::std::string;
  }
  epc_->assign(value);
}
inline void CartonContentsTag::set_epc(const char* value) {
  set_has_epc();
  if (epc_ == &::google::protobuf::internal::kEmptyString) {
    epc_ = new ::std::string;
  }
  epc_->assign(value);
}
inline void CartonContentsTag::set_epc(const void* value, size_t size) {
  set_has_epc();
  if (epc_ == &::google::protobuf::internal::kEmptyString) {
    epc_ = new ::std::string;
  }
  epc_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* CartonContentsTag::mutable_epc() {
  set_has_epc();
  if (epc_ == &::google::protobuf::internal::kEmptyString) {
    epc_ = new ::std::string;
  }
  return epc_;
}
inline ::std::string* CartonContentsTag::release_epc() {
  clear_has_epc();
  if (epc_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = epc_;
    epc_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void CartonContentsTag::set_allocated_epc(::std::string* epc) {
  if (epc_ != &::google::protobuf::internal::kEmptyString) {
    delete epc_;
  }
  if (epc) {
    set_has_epc();
    epc_ = epc;
  } else {
    clear_has_epc();
    epc_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional uint32 confidence = 3;
inline bool CartonContentsTag::has_confidence() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void CartonContentsTag::set_has_confidence() {
  _has_bits_[0] |= 0x00000004u;
}
inline void CartonContentsTag::clear_has_confidence() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void CartonContentsTag::clear_confidence() {
  confidence_ = 0u;
  clear_has_confidence();
}
inline ::google::protobuf::uint32 CartonContentsTag::confidence() const {
  return confidence_;
}
inline void CartonContentsTag::set_confidence(::google::protobuf::uint32 value) {
  set_has_confidence();
  confidence_ = value;
}

// optional uint32 metric_1 = 4;
inline bool CartonContentsTag::has_metric_1() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void CartonContentsTag::set_has_metric_1() {
  _has_bits_[0] |= 0x00000008u;
}
inline void CartonContentsTag::clear_has_metric_1() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void CartonContentsTag::clear_metric_1() {
  metric_1_ = 0u;
  clear_has_metric_1();
}
inline ::google::protobuf::uint32 CartonContentsTag::metric_1() const {
  return metric_1_;
}
inline void CartonContentsTag::set_metric_1(::google::protobuf::uint32 value) {
  set_has_metric_1();
  metric_1_ = value;
}

// optional uint32 metric_2 = 5;
inline bool CartonContentsTag::has_metric_2() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void CartonContentsTag::set_has_metric_2() {
  _has_bits_[0] |= 0x00000010u;
}
inline void CartonContentsTag::clear_has_metric_2() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void CartonContentsTag::clear_metric_2() {
  metric_2_ = 0u;
  clear_has_metric_2();
}
inline ::google::protobuf::uint32 CartonContentsTag::metric_2() const {
  return metric_2_;
}
inline void CartonContentsTag::set_metric_2(::google::protobuf::uint32 value) {
  set_has_metric_2();
  metric_2_ = value;
}

// optional uint32 metric_3 = 6;
inline bool CartonContentsTag::has_metric_3() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void CartonContentsTag::set_has_metric_3() {
  _has_bits_[0] |= 0x00000020u;
}
inline void CartonContentsTag::clear_has_metric_3() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void CartonContentsTag::clear_metric_3() {
  metric_3_ = 0u;
  clear_has_metric_3();
}
inline ::google::protobuf::uint32 CartonContentsTag::metric_3() const {
  return metric_3_;
}
inline void CartonContentsTag::set_metric_3(::google::protobuf::uint32 value) {
  set_has_metric_3();
  metric_3_ = value;
}

// -------------------------------------------------------------------

// CartonContentsReport

// optional .Impinj.STP.CartonContentsResult carton_contents_result = 1;
inline bool CartonContentsReport::has_carton_contents_result() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CartonContentsReport::set_has_carton_contents_result() {
  _has_bits_[0] |= 0x00000001u;
}
inline void CartonContentsReport::clear_has_carton_contents_result() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void CartonContentsReport::clear_carton_contents_result() {
  carton_contents_result_ = 1;
  clear_has_carton_contents_result();
}
inline ::Impinj::STP::CartonContentsResult CartonContentsReport::carton_contents_result() const {
  return static_cast< ::Impinj::STP::CartonContentsResult >(carton_contents_result_);
}
inline void CartonContentsReport::set_carton_contents_result(::Impinj::STP::CartonContentsResult value) {
  assert(::Impinj::STP::CartonContentsResult_IsValid(value));
  set_has_carton_contents_result();
  carton_contents_result_ = value;
}

// optional .Impinj.STP.Timestamp enter_timestamp = 5;
inline bool CartonContentsReport::has_enter_timestamp() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void CartonContentsReport::set_has_enter_timestamp() {
  _has_bits_[0] |= 0x00000002u;
}
inline void CartonContentsReport::clear_has_enter_timestamp() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void CartonContentsReport::clear_enter_timestamp() {
  if (enter_timestamp_ != NULL) enter_timestamp_->::Impinj::STP::Timestamp::Clear();
  clear_has_enter_timestamp();
}
inline const ::Impinj::STP::Timestamp& CartonContentsReport::enter_timestamp() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return enter_timestamp_ != NULL ? *enter_timestamp_ : *default_instance().enter_timestamp_;
#else
  return enter_timestamp_ != NULL ? *enter_timestamp_ : *default_instance_->enter_timestamp_;
#endif
}
inline ::Impinj::STP::Timestamp* CartonContentsReport::mutable_enter_timestamp() {
  set_has_enter_timestamp();
  if (enter_timestamp_ == NULL) enter_timestamp_ = new ::Impinj::STP::Timestamp;
  return enter_timestamp_;
}
inline ::Impinj::STP::Timestamp* CartonContentsReport::release_enter_timestamp() {
  clear_has_enter_timestamp();
  ::Impinj::STP::Timestamp* temp = enter_timestamp_;
  enter_timestamp_ = NULL;
  return temp;
}
inline void CartonContentsReport::set_allocated_enter_timestamp(::Impinj::STP::Timestamp* enter_timestamp) {
  delete enter_timestamp_;
  enter_timestamp_ = enter_timestamp;
  if (enter_timestamp) {
    set_has_enter_timestamp();
  } else {
    clear_has_enter_timestamp();
  }
}

// optional .Impinj.STP.Timestamp exit_timestamp = 6;
inline bool CartonContentsReport::has_exit_timestamp() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void CartonContentsReport::set_has_exit_timestamp() {
  _has_bits_[0] |= 0x00000004u;
}
inline void CartonContentsReport::clear_has_exit_timestamp() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void CartonContentsReport::clear_exit_timestamp() {
  if (exit_timestamp_ != NULL) exit_timestamp_->::Impinj::STP::Timestamp::Clear();
  clear_has_exit_timestamp();
}
inline const ::Impinj::STP::Timestamp& CartonContentsReport::exit_timestamp() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return exit_timestamp_ != NULL ? *exit_timestamp_ : *default_instance().exit_timestamp_;
#else
  return exit_timestamp_ != NULL ? *exit_timestamp_ : *default_instance_->exit_timestamp_;
#endif
}
inline ::Impinj::STP::Timestamp* CartonContentsReport::mutable_exit_timestamp() {
  set_has_exit_timestamp();
  if (exit_timestamp_ == NULL) exit_timestamp_ = new ::Impinj::STP::Timestamp;
  return exit_timestamp_;
}
inline ::Impinj::STP::Timestamp* CartonContentsReport::release_exit_timestamp() {
  clear_has_exit_timestamp();
  ::Impinj::STP::Timestamp* temp = exit_timestamp_;
  exit_timestamp_ = NULL;
  return temp;
}
inline void CartonContentsReport::set_allocated_exit_timestamp(::Impinj::STP::Timestamp* exit_timestamp) {
  delete exit_timestamp_;
  exit_timestamp_ = exit_timestamp;
  if (exit_timestamp) {
    set_has_exit_timestamp();
  } else {
    clear_has_exit_timestamp();
  }
}

// optional uint32 carton_size = 7;
inline bool CartonContentsReport::has_carton_size() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void CartonContentsReport::set_has_carton_size() {
  _has_bits_[0] |= 0x00000008u;
}
inline void CartonContentsReport::clear_has_carton_size() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void CartonContentsReport::clear_carton_size() {
  carton_size_ = 0u;
  clear_has_carton_size();
}
inline ::google::protobuf::uint32 CartonContentsReport::carton_size() const {
  return carton_size_;
}
inline void CartonContentsReport::set_carton_size(::google::protobuf::uint32 value) {
  set_has_carton_size();
  carton_size_ = value;
}

// repeated .Impinj.STP.CartonContentsTag carton_contents_tag = 4;
inline int CartonContentsReport::carton_contents_tag_size() const {
  return carton_contents_tag_.size();
}
inline void CartonContentsReport::clear_carton_contents_tag() {
  carton_contents_tag_.Clear();
}
inline const ::Impinj::STP::CartonContentsTag& CartonContentsReport::carton_contents_tag(int index) const {
  return carton_contents_tag_.Get(index);
}
inline ::Impinj::STP::CartonContentsTag* CartonContentsReport::mutable_carton_contents_tag(int index) {
  return carton_contents_tag_.Mutable(index);
}
inline ::Impinj::STP::CartonContentsTag* CartonContentsReport::add_carton_contents_tag() {
  return carton_contents_tag_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::Impinj::STP::CartonContentsTag >&
CartonContentsReport::carton_contents_tag() const {
  return carton_contents_tag_;
}
inline ::google::protobuf::RepeatedPtrField< ::Impinj::STP::CartonContentsTag >*
CartonContentsReport::mutable_carton_contents_tag() {
  return &carton_contents_tag_;
}

// repeated .Impinj.STP.CartonContentsError carton_contents_error = 8;
inline int CartonContentsReport::carton_contents_error_size() const {
  return carton_contents_error_.size();
}
inline void CartonContentsReport::clear_carton_contents_error() {
  carton_contents_error_.Clear();
}
inline const ::Impinj::STP::CartonContentsError& CartonContentsReport::carton_contents_error(int index) const {
  return carton_contents_error_.Get(index);
}
inline ::Impinj::STP::CartonContentsError* CartonContentsReport::mutable_carton_contents_error(int index) {
  return carton_contents_error_.Mutable(index);
}
inline ::Impinj::STP::CartonContentsError* CartonContentsReport::add_carton_contents_error() {
  return carton_contents_error_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::Impinj::STP::CartonContentsError >&
CartonContentsReport::carton_contents_error() const {
  return carton_contents_error_;
}
inline ::google::protobuf::RepeatedPtrField< ::Impinj::STP::CartonContentsError >*
CartonContentsReport::mutable_carton_contents_error() {
  return &carton_contents_error_;
}

// optional .Impinj.STP.Timestamp start_timestamp = 2;
inline bool CartonContentsReport::has_start_timestamp() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void CartonContentsReport::set_has_start_timestamp() {
  _has_bits_[0] |= 0x00000040u;
}
inline void CartonContentsReport::clear_has_start_timestamp() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void CartonContentsReport::clear_start_timestamp() {
  if (start_timestamp_ != NULL) start_timestamp_->::Impinj::STP::Timestamp::Clear();
  clear_has_start_timestamp();
}
inline const ::Impinj::STP::Timestamp& CartonContentsReport::start_timestamp() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return start_timestamp_ != NULL ? *start_timestamp_ : *default_instance().start_timestamp_;
#else
  return start_timestamp_ != NULL ? *start_timestamp_ : *default_instance_->start_timestamp_;
#endif
}
inline ::Impinj::STP::Timestamp* CartonContentsReport::mutable_start_timestamp() {
  set_has_start_timestamp();
  if (start_timestamp_ == NULL) start_timestamp_ = new ::Impinj::STP::Timestamp;
  return start_timestamp_;
}
inline ::Impinj::STP::Timestamp* CartonContentsReport::release_start_timestamp() {
  clear_has_start_timestamp();
  ::Impinj::STP::Timestamp* temp = start_timestamp_;
  start_timestamp_ = NULL;
  return temp;
}
inline void CartonContentsReport::set_allocated_start_timestamp(::Impinj::STP::Timestamp* start_timestamp) {
  delete start_timestamp_;
  start_timestamp_ = start_timestamp;
  if (start_timestamp) {
    set_has_start_timestamp();
  } else {
    clear_has_start_timestamp();
  }
}

// optional .Impinj.STP.Timestamp stop_timestamp = 3;
inline bool CartonContentsReport::has_stop_timestamp() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void CartonContentsReport::set_has_stop_timestamp() {
  _has_bits_[0] |= 0x00000080u;
}
inline void CartonContentsReport::clear_has_stop_timestamp() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void CartonContentsReport::clear_stop_timestamp() {
  if (stop_timestamp_ != NULL) stop_timestamp_->::Impinj::STP::Timestamp::Clear();
  clear_has_stop_timestamp();
}
inline const ::Impinj::STP::Timestamp& CartonContentsReport::stop_timestamp() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return stop_timestamp_ != NULL ? *stop_timestamp_ : *default_instance().stop_timestamp_;
#else
  return stop_timestamp_ != NULL ? *stop_timestamp_ : *default_instance_->stop_timestamp_;
#endif
}
inline ::Impinj::STP::Timestamp* CartonContentsReport::mutable_stop_timestamp() {
  set_has_stop_timestamp();
  if (stop_timestamp_ == NULL) stop_timestamp_ = new ::Impinj::STP::Timestamp;
  return stop_timestamp_;
}
inline ::Impinj::STP::Timestamp* CartonContentsReport::release_stop_timestamp() {
  clear_has_stop_timestamp();
  ::Impinj::STP::Timestamp* temp = stop_timestamp_;
  stop_timestamp_ = NULL;
  return temp;
}
inline void CartonContentsReport::set_allocated_stop_timestamp(::Impinj::STP::Timestamp* stop_timestamp) {
  delete stop_timestamp_;
  stop_timestamp_ = stop_timestamp;
  if (stop_timestamp) {
    set_has_stop_timestamp();
  } else {
    clear_has_stop_timestamp();
  }
}

// -------------------------------------------------------------------

// CartonContentsError

// optional .Impinj.STP.CartonContentsErrorType error_type = 1;
inline bool CartonContentsError::has_error_type() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CartonContentsError::set_has_error_type() {
  _has_bits_[0] |= 0x00000001u;
}
inline void CartonContentsError::clear_has_error_type() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void CartonContentsError::clear_error_type() {
  error_type_ = 1;
  clear_has_error_type();
}
inline ::Impinj::STP::CartonContentsErrorType CartonContentsError::error_type() const {
  return static_cast< ::Impinj::STP::CartonContentsErrorType >(error_type_);
}
inline void CartonContentsError::set_error_type(::Impinj::STP::CartonContentsErrorType value) {
  assert(::Impinj::STP::CartonContentsErrorType_IsValid(value));
  set_has_error_type();
  error_type_ = value;
}

// optional .Impinj.STP.Timestamp extra_timestamp = 2;
inline bool CartonContentsError::has_extra_timestamp() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void CartonContentsError::set_has_extra_timestamp() {
  _has_bits_[0] |= 0x00000002u;
}
inline void CartonContentsError::clear_has_extra_timestamp() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void CartonContentsError::clear_extra_timestamp() {
  if (extra_timestamp_ != NULL) extra_timestamp_->::Impinj::STP::Timestamp::Clear();
  clear_has_extra_timestamp();
}
inline const ::Impinj::STP::Timestamp& CartonContentsError::extra_timestamp() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return extra_timestamp_ != NULL ? *extra_timestamp_ : *default_instance().extra_timestamp_;
#else
  return extra_timestamp_ != NULL ? *extra_timestamp_ : *default_instance_->extra_timestamp_;
#endif
}
inline ::Impinj::STP::Timestamp* CartonContentsError::mutable_extra_timestamp() {
  set_has_extra_timestamp();
  if (extra_timestamp_ == NULL) extra_timestamp_ = new ::Impinj::STP::Timestamp;
  return extra_timestamp_;
}
inline ::Impinj::STP::Timestamp* CartonContentsError::release_extra_timestamp() {
  clear_has_extra_timestamp();
  ::Impinj::STP::Timestamp* temp = extra_timestamp_;
  extra_timestamp_ = NULL;
  return temp;
}
inline void CartonContentsError::set_allocated_extra_timestamp(::Impinj::STP::Timestamp* extra_timestamp) {
  delete extra_timestamp_;
  extra_timestamp_ = extra_timestamp;
  if (extra_timestamp) {
    set_has_extra_timestamp();
  } else {
    clear_has_extra_timestamp();
  }
}

// optional .Impinj.STP.Timestamp min_timestamp = 3;
inline bool CartonContentsError::has_min_timestamp() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void CartonContentsError::set_has_min_timestamp() {
  _has_bits_[0] |= 0x00000004u;
}
inline void CartonContentsError::clear_has_min_timestamp() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void CartonContentsError::clear_min_timestamp() {
  if (min_timestamp_ != NULL) min_timestamp_->::Impinj::STP::Timestamp::Clear();
  clear_has_min_timestamp();
}
inline const ::Impinj::STP::Timestamp& CartonContentsError::min_timestamp() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return min_timestamp_ != NULL ? *min_timestamp_ : *default_instance().min_timestamp_;
#else
  return min_timestamp_ != NULL ? *min_timestamp_ : *default_instance_->min_timestamp_;
#endif
}
inline ::Impinj::STP::Timestamp* CartonContentsError::mutable_min_timestamp() {
  set_has_min_timestamp();
  if (min_timestamp_ == NULL) min_timestamp_ = new ::Impinj::STP::Timestamp;
  return min_timestamp_;
}
inline ::Impinj::STP::Timestamp* CartonContentsError::release_min_timestamp() {
  clear_has_min_timestamp();
  ::Impinj::STP::Timestamp* temp = min_timestamp_;
  min_timestamp_ = NULL;
  return temp;
}
inline void CartonContentsError::set_allocated_min_timestamp(::Impinj::STP::Timestamp* min_timestamp) {
  delete min_timestamp_;
  min_timestamp_ = min_timestamp;
  if (min_timestamp) {
    set_has_min_timestamp();
  } else {
    clear_has_min_timestamp();
  }
}

// optional .Impinj.STP.Timestamp max_timestamp = 4;
inline bool CartonContentsError::has_max_timestamp() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void CartonContentsError::set_has_max_timestamp() {
  _has_bits_[0] |= 0x00000008u;
}
inline void CartonContentsError::clear_has_max_timestamp() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void CartonContentsError::clear_max_timestamp() {
  if (max_timestamp_ != NULL) max_timestamp_->::Impinj::STP::Timestamp::Clear();
  clear_has_max_timestamp();
}
inline const ::Impinj::STP::Timestamp& CartonContentsError::max_timestamp() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return max_timestamp_ != NULL ? *max_timestamp_ : *default_instance().max_timestamp_;
#else
  return max_timestamp_ != NULL ? *max_timestamp_ : *default_instance_->max_timestamp_;
#endif
}
inline ::Impinj::STP::Timestamp* CartonContentsError::mutable_max_timestamp() {
  set_has_max_timestamp();
  if (max_timestamp_ == NULL) max_timestamp_ = new ::Impinj::STP::Timestamp;
  return max_timestamp_;
}
inline ::Impinj::STP::Timestamp* CartonContentsError::release_max_timestamp() {
  clear_has_max_timestamp();
  ::Impinj::STP::Timestamp* temp = max_timestamp_;
  max_timestamp_ = NULL;
  return temp;
}
inline void CartonContentsError::set_allocated_max_timestamp(::Impinj::STP::Timestamp* max_timestamp) {
  delete max_timestamp_;
  max_timestamp_ = max_timestamp;
  if (max_timestamp) {
    set_has_max_timestamp();
  } else {
    clear_has_max_timestamp();
  }
}

// -------------------------------------------------------------------

// TagModeMetrics

// optional uint64 total_count = 1;
inline bool TagModeMetrics::has_total_count() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TagModeMetrics::set_has_total_count() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TagModeMetrics::clear_has_total_count() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TagModeMetrics::clear_total_count() {
  total_count_ = GOOGLE_ULONGLONG(0);
  clear_has_total_count();
}
inline ::google::protobuf::uint64 TagModeMetrics::total_count() const {
  return total_count_;
}
inline void TagModeMetrics::set_total_count(::google::protobuf::uint64 value) {
  set_has_total_count();
  total_count_ = value;
}

// optional uint64 pass_count = 2;
inline bool TagModeMetrics::has_pass_count() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void TagModeMetrics::set_has_pass_count() {
  _has_bits_[0] |= 0x00000002u;
}
inline void TagModeMetrics::clear_has_pass_count() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void TagModeMetrics::clear_pass_count() {
  pass_count_ = GOOGLE_ULONGLONG(0);
  clear_has_pass_count();
}
inline ::google::protobuf::uint64 TagModeMetrics::pass_count() const {
  return pass_count_;
}
inline void TagModeMetrics::set_pass_count(::google::protobuf::uint64 value) {
  set_has_pass_count();
  pass_count_ = value;
}

// optional uint64 fail_count = 3;
inline bool TagModeMetrics::has_fail_count() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void TagModeMetrics::set_has_fail_count() {
  _has_bits_[0] |= 0x00000004u;
}
inline void TagModeMetrics::clear_has_fail_count() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void TagModeMetrics::clear_fail_count() {
  fail_count_ = GOOGLE_ULONGLONG(0);
  clear_has_fail_count();
}
inline ::google::protobuf::uint64 TagModeMetrics::fail_count() const {
  return fail_count_;
}
inline void TagModeMetrics::set_fail_count(::google::protobuf::uint64 value) {
  set_has_fail_count();
  fail_count_ = value;
}

// optional uint64 void_count = 4;
inline bool TagModeMetrics::has_void_count() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void TagModeMetrics::set_has_void_count() {
  _has_bits_[0] |= 0x00000008u;
}
inline void TagModeMetrics::clear_has_void_count() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void TagModeMetrics::clear_void_count() {
  void_count_ = GOOGLE_ULONGLONG(0);
  clear_has_void_count();
}
inline ::google::protobuf::uint64 TagModeMetrics::void_count() const {
  return void_count_;
}
inline void TagModeMetrics::set_void_count(::google::protobuf::uint64 value) {
  set_has_void_count();
  void_count_ = value;
}

// -------------------------------------------------------------------

// TagMetrics

// optional bytes tag_chip = 1;
inline bool TagMetrics::has_tag_chip() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TagMetrics::set_has_tag_chip() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TagMetrics::clear_has_tag_chip() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TagMetrics::clear_tag_chip() {
  if (tag_chip_ != &::google::protobuf::internal::kEmptyString) {
    tag_chip_->clear();
  }
  clear_has_tag_chip();
}
inline const ::std::string& TagMetrics::tag_chip() const {
  return *tag_chip_;
}
inline void TagMetrics::set_tag_chip(const ::std::string& value) {
  set_has_tag_chip();
  if (tag_chip_ == &::google::protobuf::internal::kEmptyString) {
    tag_chip_ = new ::std::string;
  }
  tag_chip_->assign(value);
}
inline void TagMetrics::set_tag_chip(const char* value) {
  set_has_tag_chip();
  if (tag_chip_ == &::google::protobuf::internal::kEmptyString) {
    tag_chip_ = new ::std::string;
  }
  tag_chip_->assign(value);
}
inline void TagMetrics::set_tag_chip(const void* value, size_t size) {
  set_has_tag_chip();
  if (tag_chip_ == &::google::protobuf::internal::kEmptyString) {
    tag_chip_ = new ::std::string;
  }
  tag_chip_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* TagMetrics::mutable_tag_chip() {
  set_has_tag_chip();
  if (tag_chip_ == &::google::protobuf::internal::kEmptyString) {
    tag_chip_ = new ::std::string;
  }
  return tag_chip_;
}
inline ::std::string* TagMetrics::release_tag_chip() {
  clear_has_tag_chip();
  if (tag_chip_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = tag_chip_;
    tag_chip_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void TagMetrics::set_allocated_tag_chip(::std::string* tag_chip) {
  if (tag_chip_ != &::google::protobuf::internal::kEmptyString) {
    delete tag_chip_;
  }
  if (tag_chip) {
    set_has_tag_chip();
    tag_chip_ = tag_chip;
  } else {
    clear_has_tag_chip();
    tag_chip_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional .Impinj.STP.TagModeMetrics verify_basic_metrics = 2;
inline bool TagMetrics::has_verify_basic_metrics() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void TagMetrics::set_has_verify_basic_metrics() {
  _has_bits_[0] |= 0x00000002u;
}
inline void TagMetrics::clear_has_verify_basic_metrics() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void TagMetrics::clear_verify_basic_metrics() {
  if (verify_basic_metrics_ != NULL) verify_basic_metrics_->::Impinj::STP::TagModeMetrics::Clear();
  clear_has_verify_basic_metrics();
}
inline const ::Impinj::STP::TagModeMetrics& TagMetrics::verify_basic_metrics() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return verify_basic_metrics_ != NULL ? *verify_basic_metrics_ : *default_instance().verify_basic_metrics_;
#else
  return verify_basic_metrics_ != NULL ? *verify_basic_metrics_ : *default_instance_->verify_basic_metrics_;
#endif
}
inline ::Impinj::STP::TagModeMetrics* TagMetrics::mutable_verify_basic_metrics() {
  set_has_verify_basic_metrics();
  if (verify_basic_metrics_ == NULL) verify_basic_metrics_ = new ::Impinj::STP::TagModeMetrics;
  return verify_basic_metrics_;
}
inline ::Impinj::STP::TagModeMetrics* TagMetrics::release_verify_basic_metrics() {
  clear_has_verify_basic_metrics();
  ::Impinj::STP::TagModeMetrics* temp = verify_basic_metrics_;
  verify_basic_metrics_ = NULL;
  return temp;
}
inline void TagMetrics::set_allocated_verify_basic_metrics(::Impinj::STP::TagModeMetrics* verify_basic_metrics) {
  delete verify_basic_metrics_;
  verify_basic_metrics_ = verify_basic_metrics;
  if (verify_basic_metrics) {
    set_has_verify_basic_metrics();
  } else {
    clear_has_verify_basic_metrics();
  }
}

// optional .Impinj.STP.TagModeMetrics verify_data_metrics = 3;
inline bool TagMetrics::has_verify_data_metrics() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void TagMetrics::set_has_verify_data_metrics() {
  _has_bits_[0] |= 0x00000004u;
}
inline void TagMetrics::clear_has_verify_data_metrics() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void TagMetrics::clear_verify_data_metrics() {
  if (verify_data_metrics_ != NULL) verify_data_metrics_->::Impinj::STP::TagModeMetrics::Clear();
  clear_has_verify_data_metrics();
}
inline const ::Impinj::STP::TagModeMetrics& TagMetrics::verify_data_metrics() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return verify_data_metrics_ != NULL ? *verify_data_metrics_ : *default_instance().verify_data_metrics_;
#else
  return verify_data_metrics_ != NULL ? *verify_data_metrics_ : *default_instance_->verify_data_metrics_;
#endif
}
inline ::Impinj::STP::TagModeMetrics* TagMetrics::mutable_verify_data_metrics() {
  set_has_verify_data_metrics();
  if (verify_data_metrics_ == NULL) verify_data_metrics_ = new ::Impinj::STP::TagModeMetrics;
  return verify_data_metrics_;
}
inline ::Impinj::STP::TagModeMetrics* TagMetrics::release_verify_data_metrics() {
  clear_has_verify_data_metrics();
  ::Impinj::STP::TagModeMetrics* temp = verify_data_metrics_;
  verify_data_metrics_ = NULL;
  return temp;
}
inline void TagMetrics::set_allocated_verify_data_metrics(::Impinj::STP::TagModeMetrics* verify_data_metrics) {
  delete verify_data_metrics_;
  verify_data_metrics_ = verify_data_metrics;
  if (verify_data_metrics) {
    set_has_verify_data_metrics();
  } else {
    clear_has_verify_data_metrics();
  }
}

// optional .Impinj.STP.TagModeMetrics encode_metrics = 4;
inline bool TagMetrics::has_encode_metrics() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void TagMetrics::set_has_encode_metrics() {
  _has_bits_[0] |= 0x00000008u;
}
inline void TagMetrics::clear_has_encode_metrics() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void TagMetrics::clear_encode_metrics() {
  if (encode_metrics_ != NULL) encode_metrics_->::Impinj::STP::TagModeMetrics::Clear();
  clear_has_encode_metrics();
}
inline const ::Impinj::STP::TagModeMetrics& TagMetrics::encode_metrics() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return encode_metrics_ != NULL ? *encode_metrics_ : *default_instance().encode_metrics_;
#else
  return encode_metrics_ != NULL ? *encode_metrics_ : *default_instance_->encode_metrics_;
#endif
}
inline ::Impinj::STP::TagModeMetrics* TagMetrics::mutable_encode_metrics() {
  set_has_encode_metrics();
  if (encode_metrics_ == NULL) encode_metrics_ = new ::Impinj::STP::TagModeMetrics;
  return encode_metrics_;
}
inline ::Impinj::STP::TagModeMetrics* TagMetrics::release_encode_metrics() {
  clear_has_encode_metrics();
  ::Impinj::STP::TagModeMetrics* temp = encode_metrics_;
  encode_metrics_ = NULL;
  return temp;
}
inline void TagMetrics::set_allocated_encode_metrics(::Impinj::STP::TagModeMetrics* encode_metrics) {
  delete encode_metrics_;
  encode_metrics_ = encode_metrics;
  if (encode_metrics) {
    set_has_encode_metrics();
  } else {
    clear_has_encode_metrics();
  }
}

// optional .Impinj.STP.TagModeMetrics inventory_metrics = 5;
inline bool TagMetrics::has_inventory_metrics() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void TagMetrics::set_has_inventory_metrics() {
  _has_bits_[0] |= 0x00000010u;
}
inline void TagMetrics::clear_has_inventory_metrics() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void TagMetrics::clear_inventory_metrics() {
  if (inventory_metrics_ != NULL) inventory_metrics_->::Impinj::STP::TagModeMetrics::Clear();
  clear_has_inventory_metrics();
}
inline const ::Impinj::STP::TagModeMetrics& TagMetrics::inventory_metrics() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return inventory_metrics_ != NULL ? *inventory_metrics_ : *default_instance().inventory_metrics_;
#else
  return inventory_metrics_ != NULL ? *inventory_metrics_ : *default_instance_->inventory_metrics_;
#endif
}
inline ::Impinj::STP::TagModeMetrics* TagMetrics::mutable_inventory_metrics() {
  set_has_inventory_metrics();
  if (inventory_metrics_ == NULL) inventory_metrics_ = new ::Impinj::STP::TagModeMetrics;
  return inventory_metrics_;
}
inline ::Impinj::STP::TagModeMetrics* TagMetrics::release_inventory_metrics() {
  clear_has_inventory_metrics();
  ::Impinj::STP::TagModeMetrics* temp = inventory_metrics_;
  inventory_metrics_ = NULL;
  return temp;
}
inline void TagMetrics::set_allocated_inventory_metrics(::Impinj::STP::TagModeMetrics* inventory_metrics) {
  delete inventory_metrics_;
  inventory_metrics_ = inventory_metrics;
  if (inventory_metrics) {
    set_has_inventory_metrics();
  } else {
    clear_has_inventory_metrics();
  }
}

// optional .Impinj.STP.TagModeMetrics carton_contents_metrics = 6;
inline bool TagMetrics::has_carton_contents_metrics() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void TagMetrics::set_has_carton_contents_metrics() {
  _has_bits_[0] |= 0x00000020u;
}
inline void TagMetrics::clear_has_carton_contents_metrics() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void TagMetrics::clear_carton_contents_metrics() {
  if (carton_contents_metrics_ != NULL) carton_contents_metrics_->::Impinj::STP::TagModeMetrics::Clear();
  clear_has_carton_contents_metrics();
}
inline const ::Impinj::STP::TagModeMetrics& TagMetrics::carton_contents_metrics() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return carton_contents_metrics_ != NULL ? *carton_contents_metrics_ : *default_instance().carton_contents_metrics_;
#else
  return carton_contents_metrics_ != NULL ? *carton_contents_metrics_ : *default_instance_->carton_contents_metrics_;
#endif
}
inline ::Impinj::STP::TagModeMetrics* TagMetrics::mutable_carton_contents_metrics() {
  set_has_carton_contents_metrics();
  if (carton_contents_metrics_ == NULL) carton_contents_metrics_ = new ::Impinj::STP::TagModeMetrics;
  return carton_contents_metrics_;
}
inline ::Impinj::STP::TagModeMetrics* TagMetrics::release_carton_contents_metrics() {
  clear_has_carton_contents_metrics();
  ::Impinj::STP::TagModeMetrics* temp = carton_contents_metrics_;
  carton_contents_metrics_ = NULL;
  return temp;
}
inline void TagMetrics::set_allocated_carton_contents_metrics(::Impinj::STP::TagModeMetrics* carton_contents_metrics) {
  delete carton_contents_metrics_;
  carton_contents_metrics_ = carton_contents_metrics;
  if (carton_contents_metrics) {
    set_has_carton_contents_metrics();
  } else {
    clear_has_carton_contents_metrics();
  }
}

// -------------------------------------------------------------------

// InterDeviceCommunicationMetrics

// optional string serial_number = 1;
inline bool InterDeviceCommunicationMetrics::has_serial_number() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void InterDeviceCommunicationMetrics::set_has_serial_number() {
  _has_bits_[0] |= 0x00000001u;
}
inline void InterDeviceCommunicationMetrics::clear_has_serial_number() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void InterDeviceCommunicationMetrics::clear_serial_number() {
  if (serial_number_ != &::google::protobuf::internal::kEmptyString) {
    serial_number_->clear();
  }
  clear_has_serial_number();
}
inline const ::std::string& InterDeviceCommunicationMetrics::serial_number() const {
  return *serial_number_;
}
inline void InterDeviceCommunicationMetrics::set_serial_number(const ::std::string& value) {
  set_has_serial_number();
  if (serial_number_ == &::google::protobuf::internal::kEmptyString) {
    serial_number_ = new ::std::string;
  }
  serial_number_->assign(value);
}
inline void InterDeviceCommunicationMetrics::set_serial_number(const char* value) {
  set_has_serial_number();
  if (serial_number_ == &::google::protobuf::internal::kEmptyString) {
    serial_number_ = new ::std::string;
  }
  serial_number_->assign(value);
}
inline void InterDeviceCommunicationMetrics::set_serial_number(const char* value, size_t size) {
  set_has_serial_number();
  if (serial_number_ == &::google::protobuf::internal::kEmptyString) {
    serial_number_ = new ::std::string;
  }
  serial_number_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* InterDeviceCommunicationMetrics::mutable_serial_number() {
  set_has_serial_number();
  if (serial_number_ == &::google::protobuf::internal::kEmptyString) {
    serial_number_ = new ::std::string;
  }
  return serial_number_;
}
inline ::std::string* InterDeviceCommunicationMetrics::release_serial_number() {
  clear_has_serial_number();
  if (serial_number_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = serial_number_;
    serial_number_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void InterDeviceCommunicationMetrics::set_allocated_serial_number(::std::string* serial_number) {
  if (serial_number_ != &::google::protobuf::internal::kEmptyString) {
    delete serial_number_;
  }
  if (serial_number) {
    set_has_serial_number();
    serial_number_ = serial_number;
  } else {
    clear_has_serial_number();
    serial_number_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional uint64 received_message_count = 2;
inline bool InterDeviceCommunicationMetrics::has_received_message_count() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void InterDeviceCommunicationMetrics::set_has_received_message_count() {
  _has_bits_[0] |= 0x00000002u;
}
inline void InterDeviceCommunicationMetrics::clear_has_received_message_count() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void InterDeviceCommunicationMetrics::clear_received_message_count() {
  received_message_count_ = GOOGLE_ULONGLONG(0);
  clear_has_received_message_count();
}
inline ::google::protobuf::uint64 InterDeviceCommunicationMetrics::received_message_count() const {
  return received_message_count_;
}
inline void InterDeviceCommunicationMetrics::set_received_message_count(::google::protobuf::uint64 value) {
  set_has_received_message_count();
  received_message_count_ = value;
}

// -------------------------------------------------------------------

// OperationMetrics

// optional uint64 remaining_non_monza_encodes = 1;
inline bool OperationMetrics::has_remaining_non_monza_encodes() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void OperationMetrics::set_has_remaining_non_monza_encodes() {
  _has_bits_[0] |= 0x00000001u;
}
inline void OperationMetrics::clear_has_remaining_non_monza_encodes() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void OperationMetrics::clear_remaining_non_monza_encodes() {
  remaining_non_monza_encodes_ = GOOGLE_ULONGLONG(0);
  clear_has_remaining_non_monza_encodes();
}
inline ::google::protobuf::uint64 OperationMetrics::remaining_non_monza_encodes() const {
  return remaining_non_monza_encodes_;
}
inline void OperationMetrics::set_remaining_non_monza_encodes(::google::protobuf::uint64 value) {
  set_has_remaining_non_monza_encodes();
  remaining_non_monza_encodes_ = value;
}

// repeated .Impinj.STP.TagMetrics tag_metrics = 2;
inline int OperationMetrics::tag_metrics_size() const {
  return tag_metrics_.size();
}
inline void OperationMetrics::clear_tag_metrics() {
  tag_metrics_.Clear();
}
inline const ::Impinj::STP::TagMetrics& OperationMetrics::tag_metrics(int index) const {
  return tag_metrics_.Get(index);
}
inline ::Impinj::STP::TagMetrics* OperationMetrics::mutable_tag_metrics(int index) {
  return tag_metrics_.Mutable(index);
}
inline ::Impinj::STP::TagMetrics* OperationMetrics::add_tag_metrics() {
  return tag_metrics_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::Impinj::STP::TagMetrics >&
OperationMetrics::tag_metrics() const {
  return tag_metrics_;
}
inline ::google::protobuf::RepeatedPtrField< ::Impinj::STP::TagMetrics >*
OperationMetrics::mutable_tag_metrics() {
  return &tag_metrics_;
}

// repeated .Impinj.STP.InterDeviceCommunicationMetrics inter_device_communication_metrics = 3;
inline int OperationMetrics::inter_device_communication_metrics_size() const {
  return inter_device_communication_metrics_.size();
}
inline void OperationMetrics::clear_inter_device_communication_metrics() {
  inter_device_communication_metrics_.Clear();
}
inline const ::Impinj::STP::InterDeviceCommunicationMetrics& OperationMetrics::inter_device_communication_metrics(int index) const {
  return inter_device_communication_metrics_.Get(index);
}
inline ::Impinj::STP::InterDeviceCommunicationMetrics* OperationMetrics::mutable_inter_device_communication_metrics(int index) {
  return inter_device_communication_metrics_.Mutable(index);
}
inline ::Impinj::STP::InterDeviceCommunicationMetrics* OperationMetrics::add_inter_device_communication_metrics() {
  return inter_device_communication_metrics_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::Impinj::STP::InterDeviceCommunicationMetrics >&
OperationMetrics::inter_device_communication_metrics() const {
  return inter_device_communication_metrics_;
}
inline ::google::protobuf::RepeatedPtrField< ::Impinj::STP::InterDeviceCommunicationMetrics >*
OperationMetrics::mutable_inter_device_communication_metrics() {
  return &inter_device_communication_metrics_;
}

// optional uint64 remaining_monza_encodes = 5;
inline bool OperationMetrics::has_remaining_monza_encodes() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void OperationMetrics::set_has_remaining_monza_encodes() {
  _has_bits_[0] |= 0x00000008u;
}
inline void OperationMetrics::clear_has_remaining_monza_encodes() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void OperationMetrics::clear_remaining_monza_encodes() {
  remaining_monza_encodes_ = GOOGLE_ULONGLONG(0);
  clear_has_remaining_monza_encodes();
}
inline ::google::protobuf::uint64 OperationMetrics::remaining_monza_encodes() const {
  return remaining_monza_encodes_;
}
inline void OperationMetrics::set_remaining_monza_encodes(::google::protobuf::uint64 value) {
  set_has_remaining_monza_encodes();
  remaining_monza_encodes_ = value;
}

// -------------------------------------------------------------------

// OperationDataDetails

// optional string serial_number = 1;
inline bool OperationDataDetails::has_serial_number() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void OperationDataDetails::set_has_serial_number() {
  _has_bits_[0] |= 0x00000001u;
}
inline void OperationDataDetails::clear_has_serial_number() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void OperationDataDetails::clear_serial_number() {
  if (serial_number_ != &::google::protobuf::internal::kEmptyString) {
    serial_number_->clear();
  }
  clear_has_serial_number();
}
inline const ::std::string& OperationDataDetails::serial_number() const {
  return *serial_number_;
}
inline void OperationDataDetails::set_serial_number(const ::std::string& value) {
  set_has_serial_number();
  if (serial_number_ == &::google::protobuf::internal::kEmptyString) {
    serial_number_ = new ::std::string;
  }
  serial_number_->assign(value);
}
inline void OperationDataDetails::set_serial_number(const char* value) {
  set_has_serial_number();
  if (serial_number_ == &::google::protobuf::internal::kEmptyString) {
    serial_number_ = new ::std::string;
  }
  serial_number_->assign(value);
}
inline void OperationDataDetails::set_serial_number(const char* value, size_t size) {
  set_has_serial_number();
  if (serial_number_ == &::google::protobuf::internal::kEmptyString) {
    serial_number_ = new ::std::string;
  }
  serial_number_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* OperationDataDetails::mutable_serial_number() {
  set_has_serial_number();
  if (serial_number_ == &::google::protobuf::internal::kEmptyString) {
    serial_number_ = new ::std::string;
  }
  return serial_number_;
}
inline ::std::string* OperationDataDetails::release_serial_number() {
  clear_has_serial_number();
  if (serial_number_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = serial_number_;
    serial_number_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void OperationDataDetails::set_allocated_serial_number(::std::string* serial_number) {
  if (serial_number_ != &::google::protobuf::internal::kEmptyString) {
    delete serial_number_;
  }
  if (serial_number) {
    set_has_serial_number();
    serial_number_ = serial_number;
  } else {
    clear_has_serial_number();
    serial_number_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional string firmware_version = 2;
inline bool OperationDataDetails::has_firmware_version() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void OperationDataDetails::set_has_firmware_version() {
  _has_bits_[0] |= 0x00000002u;
}
inline void OperationDataDetails::clear_has_firmware_version() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void OperationDataDetails::clear_firmware_version() {
  if (firmware_version_ != &::google::protobuf::internal::kEmptyString) {
    firmware_version_->clear();
  }
  clear_has_firmware_version();
}
inline const ::std::string& OperationDataDetails::firmware_version() const {
  return *firmware_version_;
}
inline void OperationDataDetails::set_firmware_version(const ::std::string& value) {
  set_has_firmware_version();
  if (firmware_version_ == &::google::protobuf::internal::kEmptyString) {
    firmware_version_ = new ::std::string;
  }
  firmware_version_->assign(value);
}
inline void OperationDataDetails::set_firmware_version(const char* value) {
  set_has_firmware_version();
  if (firmware_version_ == &::google::protobuf::internal::kEmptyString) {
    firmware_version_ = new ::std::string;
  }
  firmware_version_->assign(value);
}
inline void OperationDataDetails::set_firmware_version(const char* value, size_t size) {
  set_has_firmware_version();
  if (firmware_version_ == &::google::protobuf::internal::kEmptyString) {
    firmware_version_ = new ::std::string;
  }
  firmware_version_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* OperationDataDetails::mutable_firmware_version() {
  set_has_firmware_version();
  if (firmware_version_ == &::google::protobuf::internal::kEmptyString) {
    firmware_version_ = new ::std::string;
  }
  return firmware_version_;
}
inline ::std::string* OperationDataDetails::release_firmware_version() {
  clear_has_firmware_version();
  if (firmware_version_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = firmware_version_;
    firmware_version_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void OperationDataDetails::set_allocated_firmware_version(::std::string* firmware_version) {
  if (firmware_version_ != &::google::protobuf::internal::kEmptyString) {
    delete firmware_version_;
  }
  if (firmware_version) {
    set_has_firmware_version();
    firmware_version_ = firmware_version;
  } else {
    clear_has_firmware_version();
    firmware_version_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional string region = 3;
inline bool OperationDataDetails::has_region() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void OperationDataDetails::set_has_region() {
  _has_bits_[0] |= 0x00000004u;
}
inline void OperationDataDetails::clear_has_region() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void OperationDataDetails::clear_region() {
  if (region_ != &::google::protobuf::internal::kEmptyString) {
    region_->clear();
  }
  clear_has_region();
}
inline const ::std::string& OperationDataDetails::region() const {
  return *region_;
}
inline void OperationDataDetails::set_region(const ::std::string& value) {
  set_has_region();
  if (region_ == &::google::protobuf::internal::kEmptyString) {
    region_ = new ::std::string;
  }
  region_->assign(value);
}
inline void OperationDataDetails::set_region(const char* value) {
  set_has_region();
  if (region_ == &::google::protobuf::internal::kEmptyString) {
    region_ = new ::std::string;
  }
  region_->assign(value);
}
inline void OperationDataDetails::set_region(const char* value, size_t size) {
  set_has_region();
  if (region_ == &::google::protobuf::internal::kEmptyString) {
    region_ = new ::std::string;
  }
  region_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* OperationDataDetails::mutable_region() {
  set_has_region();
  if (region_ == &::google::protobuf::internal::kEmptyString) {
    region_ = new ::std::string;
  }
  return region_;
}
inline ::std::string* OperationDataDetails::release_region() {
  clear_has_region();
  if (region_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = region_;
    region_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void OperationDataDetails::set_allocated_region(::std::string* region) {
  if (region_ != &::google::protobuf::internal::kEmptyString) {
    delete region_;
  }
  if (region) {
    set_has_region();
    region_ = region;
  } else {
    clear_has_region();
    region_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// repeated string installed_features = 4;
inline int OperationDataDetails::installed_features_size() const {
  return installed_features_.size();
}
inline void OperationDataDetails::clear_installed_features() {
  installed_features_.Clear();
}
inline const ::std::string& OperationDataDetails::installed_features(int index) const {
  return installed_features_.Get(index);
}
inline ::std::string* OperationDataDetails::mutable_installed_features(int index) {
  return installed_features_.Mutable(index);
}
inline void OperationDataDetails::set_installed_features(int index, const ::std::string& value) {
  installed_features_.Mutable(index)->assign(value);
}
inline void OperationDataDetails::set_installed_features(int index, const char* value) {
  installed_features_.Mutable(index)->assign(value);
}
inline void OperationDataDetails::set_installed_features(int index, const char* value, size_t size) {
  installed_features_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
}
inline ::std::string* OperationDataDetails::add_installed_features() {
  return installed_features_.Add();
}
inline void OperationDataDetails::add_installed_features(const ::std::string& value) {
  installed_features_.Add()->assign(value);
}
inline void OperationDataDetails::add_installed_features(const char* value) {
  installed_features_.Add()->assign(value);
}
inline void OperationDataDetails::add_installed_features(const char* value, size_t size) {
  installed_features_.Add()->assign(reinterpret_cast<const char*>(value), size);
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
OperationDataDetails::installed_features() const {
  return installed_features_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
OperationDataDetails::mutable_installed_features() {
  return &installed_features_;
}

// optional uint32 non_monza_volume_key_id = 5;
inline bool OperationDataDetails::has_non_monza_volume_key_id() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void OperationDataDetails::set_has_non_monza_volume_key_id() {
  _has_bits_[0] |= 0x00000010u;
}
inline void OperationDataDetails::clear_has_non_monza_volume_key_id() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void OperationDataDetails::clear_non_monza_volume_key_id() {
  non_monza_volume_key_id_ = 0u;
  clear_has_non_monza_volume_key_id();
}
inline ::google::protobuf::uint32 OperationDataDetails::non_monza_volume_key_id() const {
  return non_monza_volume_key_id_;
}
inline void OperationDataDetails::set_non_monza_volume_key_id(::google::protobuf::uint32 value) {
  set_has_non_monza_volume_key_id();
  non_monza_volume_key_id_ = value;
}

// optional .Impinj.STP.OperationMetrics operation_metrics = 6;
inline bool OperationDataDetails::has_operation_metrics() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void OperationDataDetails::set_has_operation_metrics() {
  _has_bits_[0] |= 0x00000020u;
}
inline void OperationDataDetails::clear_has_operation_metrics() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void OperationDataDetails::clear_operation_metrics() {
  if (operation_metrics_ != NULL) operation_metrics_->::Impinj::STP::OperationMetrics::Clear();
  clear_has_operation_metrics();
}
inline const ::Impinj::STP::OperationMetrics& OperationDataDetails::operation_metrics() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return operation_metrics_ != NULL ? *operation_metrics_ : *default_instance().operation_metrics_;
#else
  return operation_metrics_ != NULL ? *operation_metrics_ : *default_instance_->operation_metrics_;
#endif
}
inline ::Impinj::STP::OperationMetrics* OperationDataDetails::mutable_operation_metrics() {
  set_has_operation_metrics();
  if (operation_metrics_ == NULL) operation_metrics_ = new ::Impinj::STP::OperationMetrics;
  return operation_metrics_;
}
inline ::Impinj::STP::OperationMetrics* OperationDataDetails::release_operation_metrics() {
  clear_has_operation_metrics();
  ::Impinj::STP::OperationMetrics* temp = operation_metrics_;
  operation_metrics_ = NULL;
  return temp;
}
inline void OperationDataDetails::set_allocated_operation_metrics(::Impinj::STP::OperationMetrics* operation_metrics) {
  delete operation_metrics_;
  operation_metrics_ = operation_metrics;
  if (operation_metrics) {
    set_has_operation_metrics();
  } else {
    clear_has_operation_metrics();
  }
}

// optional uint32 monza_volume_key_id = 7;
inline bool OperationDataDetails::has_monza_volume_key_id() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void OperationDataDetails::set_has_monza_volume_key_id() {
  _has_bits_[0] |= 0x00000040u;
}
inline void OperationDataDetails::clear_has_monza_volume_key_id() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void OperationDataDetails::clear_monza_volume_key_id() {
  monza_volume_key_id_ = 0u;
  clear_has_monza_volume_key_id();
}
inline ::google::protobuf::uint32 OperationDataDetails::monza_volume_key_id() const {
  return monza_volume_key_id_;
}
inline void OperationDataDetails::set_monza_volume_key_id(::google::protobuf::uint32 value) {
  set_has_monza_volume_key_id();
  monza_volume_key_id_ = value;
}

// -------------------------------------------------------------------

// OperationData

// optional .Impinj.STP.OperationDataDetails operation_details = 1;
inline bool OperationData::has_operation_details() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void OperationData::set_has_operation_details() {
  _has_bits_[0] |= 0x00000001u;
}
inline void OperationData::clear_has_operation_details() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void OperationData::clear_operation_details() {
  if (operation_details_ != NULL) operation_details_->::Impinj::STP::OperationDataDetails::Clear();
  clear_has_operation_details();
}
inline const ::Impinj::STP::OperationDataDetails& OperationData::operation_details() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return operation_details_ != NULL ? *operation_details_ : *default_instance().operation_details_;
#else
  return operation_details_ != NULL ? *operation_details_ : *default_instance_->operation_details_;
#endif
}
inline ::Impinj::STP::OperationDataDetails* OperationData::mutable_operation_details() {
  set_has_operation_details();
  if (operation_details_ == NULL) operation_details_ = new ::Impinj::STP::OperationDataDetails;
  return operation_details_;
}
inline ::Impinj::STP::OperationDataDetails* OperationData::release_operation_details() {
  clear_has_operation_details();
  ::Impinj::STP::OperationDataDetails* temp = operation_details_;
  operation_details_ = NULL;
  return temp;
}
inline void OperationData::set_allocated_operation_details(::Impinj::STP::OperationDataDetails* operation_details) {
  delete operation_details_;
  operation_details_ = operation_details;
  if (operation_details) {
    set_has_operation_details();
  } else {
    clear_has_operation_details();
  }
}

// repeated string data = 2;
inline int OperationData::data_size() const {
  return data_.size();
}
inline void OperationData::clear_data() {
  data_.Clear();
}
inline const ::std::string& OperationData::data(int index) const {
  return data_.Get(index);
}
inline ::std::string* OperationData::mutable_data(int index) {
  return data_.Mutable(index);
}
inline void OperationData::set_data(int index, const ::std::string& value) {
  data_.Mutable(index)->assign(value);
}
inline void OperationData::set_data(int index, const char* value) {
  data_.Mutable(index)->assign(value);
}
inline void OperationData::set_data(int index, const char* value, size_t size) {
  data_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
}
inline ::std::string* OperationData::add_data() {
  return data_.Add();
}
inline void OperationData::add_data(const ::std::string& value) {
  data_.Add()->assign(value);
}
inline void OperationData::add_data(const char* value) {
  data_.Add()->assign(value);
}
inline void OperationData::add_data(const char* value, size_t size) {
  data_.Add()->assign(reinterpret_cast<const char*>(value), size);
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
OperationData::data() const {
  return data_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
OperationData::mutable_data() {
  return &data_;
}

// -------------------------------------------------------------------

// LicenseKey

// required bytes license_key_payload = 1;
inline bool LicenseKey::has_license_key_payload() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void LicenseKey::set_has_license_key_payload() {
  _has_bits_[0] |= 0x00000001u;
}
inline void LicenseKey::clear_has_license_key_payload() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void LicenseKey::clear_license_key_payload() {
  if (license_key_payload_ != &::google::protobuf::internal::kEmptyString) {
    license_key_payload_->clear();
  }
  clear_has_license_key_payload();
}
inline const ::std::string& LicenseKey::license_key_payload() const {
  return *license_key_payload_;
}
inline void LicenseKey::set_license_key_payload(const ::std::string& value) {
  set_has_license_key_payload();
  if (license_key_payload_ == &::google::protobuf::internal::kEmptyString) {
    license_key_payload_ = new ::std::string;
  }
  license_key_payload_->assign(value);
}
inline void LicenseKey::set_license_key_payload(const char* value) {
  set_has_license_key_payload();
  if (license_key_payload_ == &::google::protobuf::internal::kEmptyString) {
    license_key_payload_ = new ::std::string;
  }
  license_key_payload_->assign(value);
}
inline void LicenseKey::set_license_key_payload(const void* value, size_t size) {
  set_has_license_key_payload();
  if (license_key_payload_ == &::google::protobuf::internal::kEmptyString) {
    license_key_payload_ = new ::std::string;
  }
  license_key_payload_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* LicenseKey::mutable_license_key_payload() {
  set_has_license_key_payload();
  if (license_key_payload_ == &::google::protobuf::internal::kEmptyString) {
    license_key_payload_ = new ::std::string;
  }
  return license_key_payload_;
}
inline ::std::string* LicenseKey::release_license_key_payload() {
  clear_has_license_key_payload();
  if (license_key_payload_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = license_key_payload_;
    license_key_payload_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void LicenseKey::set_allocated_license_key_payload(::std::string* license_key_payload) {
  if (license_key_payload_ != &::google::protobuf::internal::kEmptyString) {
    delete license_key_payload_;
  }
  if (license_key_payload) {
    set_has_license_key_payload();
    license_key_payload_ = license_key_payload;
  } else {
    clear_has_license_key_payload();
    license_key_payload_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// -------------------------------------------------------------------

// OperationEvent

// required .Impinj.STP.Timestamp timestamp = 1;
inline bool OperationEvent::has_timestamp() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void OperationEvent::set_has_timestamp() {
  _has_bits_[0] |= 0x00000001u;
}
inline void OperationEvent::clear_has_timestamp() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void OperationEvent::clear_timestamp() {
  if (timestamp_ != NULL) timestamp_->::Impinj::STP::Timestamp::Clear();
  clear_has_timestamp();
}
inline const ::Impinj::STP::Timestamp& OperationEvent::timestamp() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return timestamp_ != NULL ? *timestamp_ : *default_instance().timestamp_;
#else
  return timestamp_ != NULL ? *timestamp_ : *default_instance_->timestamp_;
#endif
}
inline ::Impinj::STP::Timestamp* OperationEvent::mutable_timestamp() {
  set_has_timestamp();
  if (timestamp_ == NULL) timestamp_ = new ::Impinj::STP::Timestamp;
  return timestamp_;
}
inline ::Impinj::STP::Timestamp* OperationEvent::release_timestamp() {
  clear_has_timestamp();
  ::Impinj::STP::Timestamp* temp = timestamp_;
  timestamp_ = NULL;
  return temp;
}
inline void OperationEvent::set_allocated_timestamp(::Impinj::STP::Timestamp* timestamp) {
  delete timestamp_;
  timestamp_ = timestamp;
  if (timestamp) {
    set_has_timestamp();
  } else {
    clear_has_timestamp();
  }
}

// required .Impinj.STP.OperationEventType operation_event_type = 2;
inline bool OperationEvent::has_operation_event_type() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void OperationEvent::set_has_operation_event_type() {
  _has_bits_[0] |= 0x00000002u;
}
inline void OperationEvent::clear_has_operation_event_type() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void OperationEvent::clear_operation_event_type() {
  operation_event_type_ = 1;
  clear_has_operation_event_type();
}
inline ::Impinj::STP::OperationEventType OperationEvent::operation_event_type() const {
  return static_cast< ::Impinj::STP::OperationEventType >(operation_event_type_);
}
inline void OperationEvent::set_operation_event_type(::Impinj::STP::OperationEventType value) {
  assert(::Impinj::STP::OperationEventType_IsValid(value));
  set_has_operation_event_type();
  operation_event_type_ = value;
}

// optional .Impinj.STP.OperationTriggerType operation_trigger_type = 3;
inline bool OperationEvent::has_operation_trigger_type() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void OperationEvent::set_has_operation_trigger_type() {
  _has_bits_[0] |= 0x00000004u;
}
inline void OperationEvent::clear_has_operation_trigger_type() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void OperationEvent::clear_operation_trigger_type() {
  operation_trigger_type_ = 1;
  clear_has_operation_trigger_type();
}
inline ::Impinj::STP::OperationTriggerType OperationEvent::operation_trigger_type() const {
  return static_cast< ::Impinj::STP::OperationTriggerType >(operation_trigger_type_);
}
inline void OperationEvent::set_operation_trigger_type(::Impinj::STP::OperationTriggerType value) {
  assert(::Impinj::STP::OperationTriggerType_IsValid(value));
  set_has_operation_trigger_type();
  operation_trigger_type_ = value;
}

// -------------------------------------------------------------------

// DeviceExceptionEvent

// required .Impinj.STP.Timestamp timestamp = 1;
inline bool DeviceExceptionEvent::has_timestamp() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void DeviceExceptionEvent::set_has_timestamp() {
  _has_bits_[0] |= 0x00000001u;
}
inline void DeviceExceptionEvent::clear_has_timestamp() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void DeviceExceptionEvent::clear_timestamp() {
  if (timestamp_ != NULL) timestamp_->::Impinj::STP::Timestamp::Clear();
  clear_has_timestamp();
}
inline const ::Impinj::STP::Timestamp& DeviceExceptionEvent::timestamp() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return timestamp_ != NULL ? *timestamp_ : *default_instance().timestamp_;
#else
  return timestamp_ != NULL ? *timestamp_ : *default_instance_->timestamp_;
#endif
}
inline ::Impinj::STP::Timestamp* DeviceExceptionEvent::mutable_timestamp() {
  set_has_timestamp();
  if (timestamp_ == NULL) timestamp_ = new ::Impinj::STP::Timestamp;
  return timestamp_;
}
inline ::Impinj::STP::Timestamp* DeviceExceptionEvent::release_timestamp() {
  clear_has_timestamp();
  ::Impinj::STP::Timestamp* temp = timestamp_;
  timestamp_ = NULL;
  return temp;
}
inline void DeviceExceptionEvent::set_allocated_timestamp(::Impinj::STP::Timestamp* timestamp) {
  delete timestamp_;
  timestamp_ = timestamp;
  if (timestamp) {
    set_has_timestamp();
  } else {
    clear_has_timestamp();
  }
}

// required .Impinj.STP.DeviceExceptionEventType device_exception_event_type = 2;
inline bool DeviceExceptionEvent::has_device_exception_event_type() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void DeviceExceptionEvent::set_has_device_exception_event_type() {
  _has_bits_[0] |= 0x00000002u;
}
inline void DeviceExceptionEvent::clear_has_device_exception_event_type() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void DeviceExceptionEvent::clear_device_exception_event_type() {
  device_exception_event_type_ = 1;
  clear_has_device_exception_event_type();
}
inline ::Impinj::STP::DeviceExceptionEventType DeviceExceptionEvent::device_exception_event_type() const {
  return static_cast< ::Impinj::STP::DeviceExceptionEventType >(device_exception_event_type_);
}
inline void DeviceExceptionEvent::set_device_exception_event_type(::Impinj::STP::DeviceExceptionEventType value) {
  assert(::Impinj::STP::DeviceExceptionEventType_IsValid(value));
  set_has_device_exception_event_type();
  device_exception_event_type_ = value;
}

// required string exception_detail = 3;
inline bool DeviceExceptionEvent::has_exception_detail() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void DeviceExceptionEvent::set_has_exception_detail() {
  _has_bits_[0] |= 0x00000004u;
}
inline void DeviceExceptionEvent::clear_has_exception_detail() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void DeviceExceptionEvent::clear_exception_detail() {
  if (exception_detail_ != &::google::protobuf::internal::kEmptyString) {
    exception_detail_->clear();
  }
  clear_has_exception_detail();
}
inline const ::std::string& DeviceExceptionEvent::exception_detail() const {
  return *exception_detail_;
}
inline void DeviceExceptionEvent::set_exception_detail(const ::std::string& value) {
  set_has_exception_detail();
  if (exception_detail_ == &::google::protobuf::internal::kEmptyString) {
    exception_detail_ = new ::std::string;
  }
  exception_detail_->assign(value);
}
inline void DeviceExceptionEvent::set_exception_detail(const char* value) {
  set_has_exception_detail();
  if (exception_detail_ == &::google::protobuf::internal::kEmptyString) {
    exception_detail_ = new ::std::string;
  }
  exception_detail_->assign(value);
}
inline void DeviceExceptionEvent::set_exception_detail(const char* value, size_t size) {
  set_has_exception_detail();
  if (exception_detail_ == &::google::protobuf::internal::kEmptyString) {
    exception_detail_ = new ::std::string;
  }
  exception_detail_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* DeviceExceptionEvent::mutable_exception_detail() {
  set_has_exception_detail();
  if (exception_detail_ == &::google::protobuf::internal::kEmptyString) {
    exception_detail_ = new ::std::string;
  }
  return exception_detail_;
}
inline ::std::string* DeviceExceptionEvent::release_exception_detail() {
  clear_has_exception_detail();
  if (exception_detail_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = exception_detail_;
    exception_detail_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void DeviceExceptionEvent::set_allocated_exception_detail(::std::string* exception_detail) {
  if (exception_detail_ != &::google::protobuf::internal::kEmptyString) {
    delete exception_detail_;
  }
  if (exception_detail) {
    set_has_exception_detail();
    exception_detail_ = exception_detail;
  } else {
    clear_has_exception_detail();
    exception_detail_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// -------------------------------------------------------------------

// GPIEvent

// required .Impinj.STP.Timestamp timestamp = 1;
inline bool GPIEvent::has_timestamp() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GPIEvent::set_has_timestamp() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GPIEvent::clear_has_timestamp() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GPIEvent::clear_timestamp() {
  if (timestamp_ != NULL) timestamp_->::Impinj::STP::Timestamp::Clear();
  clear_has_timestamp();
}
inline const ::Impinj::STP::Timestamp& GPIEvent::timestamp() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return timestamp_ != NULL ? *timestamp_ : *default_instance().timestamp_;
#else
  return timestamp_ != NULL ? *timestamp_ : *default_instance_->timestamp_;
#endif
}
inline ::Impinj::STP::Timestamp* GPIEvent::mutable_timestamp() {
  set_has_timestamp();
  if (timestamp_ == NULL) timestamp_ = new ::Impinj::STP::Timestamp;
  return timestamp_;
}
inline ::Impinj::STP::Timestamp* GPIEvent::release_timestamp() {
  clear_has_timestamp();
  ::Impinj::STP::Timestamp* temp = timestamp_;
  timestamp_ = NULL;
  return temp;
}
inline void GPIEvent::set_allocated_timestamp(::Impinj::STP::Timestamp* timestamp) {
  delete timestamp_;
  timestamp_ = timestamp;
  if (timestamp) {
    set_has_timestamp();
  } else {
    clear_has_timestamp();
  }
}

// required uint32 gpi_state = 2;
inline bool GPIEvent::has_gpi_state() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void GPIEvent::set_has_gpi_state() {
  _has_bits_[0] |= 0x00000002u;
}
inline void GPIEvent::clear_has_gpi_state() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void GPIEvent::clear_gpi_state() {
  gpi_state_ = 0u;
  clear_has_gpi_state();
}
inline ::google::protobuf::uint32 GPIEvent::gpi_state() const {
  return gpi_state_;
}
inline void GPIEvent::set_gpi_state(::google::protobuf::uint32 value) {
  set_has_gpi_state();
  gpi_state_ = value;
}

// -------------------------------------------------------------------

// LowEncodeVolumeEvent

// optional .Impinj.STP.LowEncodeVolumeEventType low_encode_volume_event_type = 1;
inline bool LowEncodeVolumeEvent::has_low_encode_volume_event_type() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void LowEncodeVolumeEvent::set_has_low_encode_volume_event_type() {
  _has_bits_[0] |= 0x00000001u;
}
inline void LowEncodeVolumeEvent::clear_has_low_encode_volume_event_type() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void LowEncodeVolumeEvent::clear_low_encode_volume_event_type() {
  low_encode_volume_event_type_ = 1;
  clear_has_low_encode_volume_event_type();
}
inline ::Impinj::STP::LowEncodeVolumeEventType LowEncodeVolumeEvent::low_encode_volume_event_type() const {
  return static_cast< ::Impinj::STP::LowEncodeVolumeEventType >(low_encode_volume_event_type_);
}
inline void LowEncodeVolumeEvent::set_low_encode_volume_event_type(::Impinj::STP::LowEncodeVolumeEventType value) {
  assert(::Impinj::STP::LowEncodeVolumeEventType_IsValid(value));
  set_has_low_encode_volume_event_type();
  low_encode_volume_event_type_ = value;
}

// optional uint64 remaining_monza_encodes = 2;
inline bool LowEncodeVolumeEvent::has_remaining_monza_encodes() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void LowEncodeVolumeEvent::set_has_remaining_monza_encodes() {
  _has_bits_[0] |= 0x00000002u;
}
inline void LowEncodeVolumeEvent::clear_has_remaining_monza_encodes() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void LowEncodeVolumeEvent::clear_remaining_monza_encodes() {
  remaining_monza_encodes_ = GOOGLE_ULONGLONG(0);
  clear_has_remaining_monza_encodes();
}
inline ::google::protobuf::uint64 LowEncodeVolumeEvent::remaining_monza_encodes() const {
  return remaining_monza_encodes_;
}
inline void LowEncodeVolumeEvent::set_remaining_monza_encodes(::google::protobuf::uint64 value) {
  set_has_remaining_monza_encodes();
  remaining_monza_encodes_ = value;
}

// optional uint64 remaining_non_monza_encodes = 3;
inline bool LowEncodeVolumeEvent::has_remaining_non_monza_encodes() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void LowEncodeVolumeEvent::set_has_remaining_non_monza_encodes() {
  _has_bits_[0] |= 0x00000004u;
}
inline void LowEncodeVolumeEvent::clear_has_remaining_non_monza_encodes() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void LowEncodeVolumeEvent::clear_remaining_non_monza_encodes() {
  remaining_non_monza_encodes_ = GOOGLE_ULONGLONG(0);
  clear_has_remaining_non_monza_encodes();
}
inline ::google::protobuf::uint64 LowEncodeVolumeEvent::remaining_non_monza_encodes() const {
  return remaining_non_monza_encodes_;
}
inline void LowEncodeVolumeEvent::set_remaining_non_monza_encodes(::google::protobuf::uint64 value) {
  set_has_remaining_non_monza_encodes();
  remaining_non_monza_encodes_ = value;
}

// -------------------------------------------------------------------

// DeviceEventReport

// optional .Impinj.STP.OperationEvent operation_event = 1;
inline bool DeviceEventReport::has_operation_event() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void DeviceEventReport::set_has_operation_event() {
  _has_bits_[0] |= 0x00000001u;
}
inline void DeviceEventReport::clear_has_operation_event() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void DeviceEventReport::clear_operation_event() {
  if (operation_event_ != NULL) operation_event_->::Impinj::STP::OperationEvent::Clear();
  clear_has_operation_event();
}
inline const ::Impinj::STP::OperationEvent& DeviceEventReport::operation_event() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return operation_event_ != NULL ? *operation_event_ : *default_instance().operation_event_;
#else
  return operation_event_ != NULL ? *operation_event_ : *default_instance_->operation_event_;
#endif
}
inline ::Impinj::STP::OperationEvent* DeviceEventReport::mutable_operation_event() {
  set_has_operation_event();
  if (operation_event_ == NULL) operation_event_ = new ::Impinj::STP::OperationEvent;
  return operation_event_;
}
inline ::Impinj::STP::OperationEvent* DeviceEventReport::release_operation_event() {
  clear_has_operation_event();
  ::Impinj::STP::OperationEvent* temp = operation_event_;
  operation_event_ = NULL;
  return temp;
}
inline void DeviceEventReport::set_allocated_operation_event(::Impinj::STP::OperationEvent* operation_event) {
  delete operation_event_;
  operation_event_ = operation_event;
  if (operation_event) {
    set_has_operation_event();
  } else {
    clear_has_operation_event();
  }
}

// optional .Impinj.STP.GPIEvent GPI_event = 3;
inline bool DeviceEventReport::has_gpi_event() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void DeviceEventReport::set_has_gpi_event() {
  _has_bits_[0] |= 0x00000002u;
}
inline void DeviceEventReport::clear_has_gpi_event() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void DeviceEventReport::clear_gpi_event() {
  if (gpi_event_ != NULL) gpi_event_->::Impinj::STP::GPIEvent::Clear();
  clear_has_gpi_event();
}
inline const ::Impinj::STP::GPIEvent& DeviceEventReport::gpi_event() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return gpi_event_ != NULL ? *gpi_event_ : *default_instance().gpi_event_;
#else
  return gpi_event_ != NULL ? *gpi_event_ : *default_instance_->gpi_event_;
#endif
}
inline ::Impinj::STP::GPIEvent* DeviceEventReport::mutable_gpi_event() {
  set_has_gpi_event();
  if (gpi_event_ == NULL) gpi_event_ = new ::Impinj::STP::GPIEvent;
  return gpi_event_;
}
inline ::Impinj::STP::GPIEvent* DeviceEventReport::release_gpi_event() {
  clear_has_gpi_event();
  ::Impinj::STP::GPIEvent* temp = gpi_event_;
  gpi_event_ = NULL;
  return temp;
}
inline void DeviceEventReport::set_allocated_gpi_event(::Impinj::STP::GPIEvent* gpi_event) {
  delete gpi_event_;
  gpi_event_ = gpi_event;
  if (gpi_event) {
    set_has_gpi_event();
  } else {
    clear_has_gpi_event();
  }
}

// optional .Impinj.STP.DeviceExceptionEvent device_exception_event = 5;
inline bool DeviceEventReport::has_device_exception_event() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void DeviceEventReport::set_has_device_exception_event() {
  _has_bits_[0] |= 0x00000004u;
}
inline void DeviceEventReport::clear_has_device_exception_event() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void DeviceEventReport::clear_device_exception_event() {
  if (device_exception_event_ != NULL) device_exception_event_->::Impinj::STP::DeviceExceptionEvent::Clear();
  clear_has_device_exception_event();
}
inline const ::Impinj::STP::DeviceExceptionEvent& DeviceEventReport::device_exception_event() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return device_exception_event_ != NULL ? *device_exception_event_ : *default_instance().device_exception_event_;
#else
  return device_exception_event_ != NULL ? *device_exception_event_ : *default_instance_->device_exception_event_;
#endif
}
inline ::Impinj::STP::DeviceExceptionEvent* DeviceEventReport::mutable_device_exception_event() {
  set_has_device_exception_event();
  if (device_exception_event_ == NULL) device_exception_event_ = new ::Impinj::STP::DeviceExceptionEvent;
  return device_exception_event_;
}
inline ::Impinj::STP::DeviceExceptionEvent* DeviceEventReport::release_device_exception_event() {
  clear_has_device_exception_event();
  ::Impinj::STP::DeviceExceptionEvent* temp = device_exception_event_;
  device_exception_event_ = NULL;
  return temp;
}
inline void DeviceEventReport::set_allocated_device_exception_event(::Impinj::STP::DeviceExceptionEvent* device_exception_event) {
  delete device_exception_event_;
  device_exception_event_ = device_exception_event;
  if (device_exception_event) {
    set_has_device_exception_event();
  } else {
    clear_has_device_exception_event();
  }
}

// optional .Impinj.STP.LowEncodeVolumeEvent low_encode_volume_event = 6;
inline bool DeviceEventReport::has_low_encode_volume_event() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void DeviceEventReport::set_has_low_encode_volume_event() {
  _has_bits_[0] |= 0x00000008u;
}
inline void DeviceEventReport::clear_has_low_encode_volume_event() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void DeviceEventReport::clear_low_encode_volume_event() {
  if (low_encode_volume_event_ != NULL) low_encode_volume_event_->::Impinj::STP::LowEncodeVolumeEvent::Clear();
  clear_has_low_encode_volume_event();
}
inline const ::Impinj::STP::LowEncodeVolumeEvent& DeviceEventReport::low_encode_volume_event() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return low_encode_volume_event_ != NULL ? *low_encode_volume_event_ : *default_instance().low_encode_volume_event_;
#else
  return low_encode_volume_event_ != NULL ? *low_encode_volume_event_ : *default_instance_->low_encode_volume_event_;
#endif
}
inline ::Impinj::STP::LowEncodeVolumeEvent* DeviceEventReport::mutable_low_encode_volume_event() {
  set_has_low_encode_volume_event();
  if (low_encode_volume_event_ == NULL) low_encode_volume_event_ = new ::Impinj::STP::LowEncodeVolumeEvent;
  return low_encode_volume_event_;
}
inline ::Impinj::STP::LowEncodeVolumeEvent* DeviceEventReport::release_low_encode_volume_event() {
  clear_has_low_encode_volume_event();
  ::Impinj::STP::LowEncodeVolumeEvent* temp = low_encode_volume_event_;
  low_encode_volume_event_ = NULL;
  return temp;
}
inline void DeviceEventReport::set_allocated_low_encode_volume_event(::Impinj::STP::LowEncodeVolumeEvent* low_encode_volume_event) {
  delete low_encode_volume_event_;
  low_encode_volume_event_ = low_encode_volume_event;
  if (low_encode_volume_event) {
    set_has_low_encode_volume_event();
  } else {
    clear_has_low_encode_volume_event();
  }
}

// -------------------------------------------------------------------

// GetAntennaConfigCommand

// optional bool reserved = 1;
inline bool GetAntennaConfigCommand::has_reserved() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GetAntennaConfigCommand::set_has_reserved() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GetAntennaConfigCommand::clear_has_reserved() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GetAntennaConfigCommand::clear_reserved() {
  reserved_ = false;
  clear_has_reserved();
}
inline bool GetAntennaConfigCommand::reserved() const {
  return reserved_;
}
inline void GetAntennaConfigCommand::set_reserved(bool value) {
  set_has_reserved();
  reserved_ = value;
}

// -------------------------------------------------------------------

// SetAntennaConfigCommand

// optional .Impinj.STP.AntennasConfig antennas_config = 1;
inline bool SetAntennaConfigCommand::has_antennas_config() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void SetAntennaConfigCommand::set_has_antennas_config() {
  _has_bits_[0] |= 0x00000001u;
}
inline void SetAntennaConfigCommand::clear_has_antennas_config() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void SetAntennaConfigCommand::clear_antennas_config() {
  if (antennas_config_ != NULL) antennas_config_->::Impinj::STP::AntennasConfig::Clear();
  clear_has_antennas_config();
}
inline const ::Impinj::STP::AntennasConfig& SetAntennaConfigCommand::antennas_config() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return antennas_config_ != NULL ? *antennas_config_ : *default_instance().antennas_config_;
#else
  return antennas_config_ != NULL ? *antennas_config_ : *default_instance_->antennas_config_;
#endif
}
inline ::Impinj::STP::AntennasConfig* SetAntennaConfigCommand::mutable_antennas_config() {
  set_has_antennas_config();
  if (antennas_config_ == NULL) antennas_config_ = new ::Impinj::STP::AntennasConfig;
  return antennas_config_;
}
inline ::Impinj::STP::AntennasConfig* SetAntennaConfigCommand::release_antennas_config() {
  clear_has_antennas_config();
  ::Impinj::STP::AntennasConfig* temp = antennas_config_;
  antennas_config_ = NULL;
  return temp;
}
inline void SetAntennaConfigCommand::set_allocated_antennas_config(::Impinj::STP::AntennasConfig* antennas_config) {
  delete antennas_config_;
  antennas_config_ = antennas_config;
  if (antennas_config) {
    set_has_antennas_config();
  } else {
    clear_has_antennas_config();
  }
}

// -------------------------------------------------------------------

// StartCommand

// optional bool reserved = 1;
inline bool StartCommand::has_reserved() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void StartCommand::set_has_reserved() {
  _has_bits_[0] |= 0x00000001u;
}
inline void StartCommand::clear_has_reserved() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void StartCommand::clear_reserved() {
  reserved_ = false;
  clear_has_reserved();
}
inline bool StartCommand::reserved() const {
  return reserved_;
}
inline void StartCommand::set_reserved(bool value) {
  set_has_reserved();
  reserved_ = value;
}

// -------------------------------------------------------------------

// SetDeviceConfigCommand

// required .Impinj.STP.DeviceConfig device_config = 1;
inline bool SetDeviceConfigCommand::has_device_config() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void SetDeviceConfigCommand::set_has_device_config() {
  _has_bits_[0] |= 0x00000001u;
}
inline void SetDeviceConfigCommand::clear_has_device_config() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void SetDeviceConfigCommand::clear_device_config() {
  if (device_config_ != NULL) device_config_->::Impinj::STP::DeviceConfig::Clear();
  clear_has_device_config();
}
inline const ::Impinj::STP::DeviceConfig& SetDeviceConfigCommand::device_config() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return device_config_ != NULL ? *device_config_ : *default_instance().device_config_;
#else
  return device_config_ != NULL ? *device_config_ : *default_instance_->device_config_;
#endif
}
inline ::Impinj::STP::DeviceConfig* SetDeviceConfigCommand::mutable_device_config() {
  set_has_device_config();
  if (device_config_ == NULL) device_config_ = new ::Impinj::STP::DeviceConfig;
  return device_config_;
}
inline ::Impinj::STP::DeviceConfig* SetDeviceConfigCommand::release_device_config() {
  clear_has_device_config();
  ::Impinj::STP::DeviceConfig* temp = device_config_;
  device_config_ = NULL;
  return temp;
}
inline void SetDeviceConfigCommand::set_allocated_device_config(::Impinj::STP::DeviceConfig* device_config) {
  delete device_config_;
  device_config_ = device_config;
  if (device_config) {
    set_has_device_config();
  } else {
    clear_has_device_config();
  }
}

// -------------------------------------------------------------------

// GetDeviceConfigCommand

// optional bool reserved = 1;
inline bool GetDeviceConfigCommand::has_reserved() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GetDeviceConfigCommand::set_has_reserved() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GetDeviceConfigCommand::clear_has_reserved() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GetDeviceConfigCommand::clear_reserved() {
  reserved_ = false;
  clear_has_reserved();
}
inline bool GetDeviceConfigCommand::reserved() const {
  return reserved_;
}
inline void GetDeviceConfigCommand::set_reserved(bool value) {
  set_has_reserved();
  reserved_ = value;
}

// -------------------------------------------------------------------

// EngageCommand

// optional bool reserved = 1;
inline bool EngageCommand::has_reserved() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void EngageCommand::set_has_reserved() {
  _has_bits_[0] |= 0x00000001u;
}
inline void EngageCommand::clear_has_reserved() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void EngageCommand::clear_reserved() {
  reserved_ = false;
  clear_has_reserved();
}
inline bool EngageCommand::reserved() const {
  return reserved_;
}
inline void EngageCommand::set_reserved(bool value) {
  set_has_reserved();
  reserved_ = value;
}

// -------------------------------------------------------------------

// DisengageCommand

// optional bool reserved = 1;
inline bool DisengageCommand::has_reserved() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void DisengageCommand::set_has_reserved() {
  _has_bits_[0] |= 0x00000001u;
}
inline void DisengageCommand::clear_has_reserved() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void DisengageCommand::clear_reserved() {
  reserved_ = false;
  clear_has_reserved();
}
inline bool DisengageCommand::reserved() const {
  return reserved_;
}
inline void DisengageCommand::set_reserved(bool value) {
  set_has_reserved();
  reserved_ = value;
}

// -------------------------------------------------------------------

// SetOperationResultGPOCommand

// optional .Impinj.STP.OperationSummaryResult operation_summary_result = 1;
inline bool SetOperationResultGPOCommand::has_operation_summary_result() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void SetOperationResultGPOCommand::set_has_operation_summary_result() {
  _has_bits_[0] |= 0x00000001u;
}
inline void SetOperationResultGPOCommand::clear_has_operation_summary_result() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void SetOperationResultGPOCommand::clear_operation_summary_result() {
  operation_summary_result_ = 0;
  clear_has_operation_summary_result();
}
inline ::Impinj::STP::OperationSummaryResult SetOperationResultGPOCommand::operation_summary_result() const {
  return static_cast< ::Impinj::STP::OperationSummaryResult >(operation_summary_result_);
}
inline void SetOperationResultGPOCommand::set_operation_summary_result(::Impinj::STP::OperationSummaryResult value) {
  assert(::Impinj::STP::OperationSummaryResult_IsValid(value));
  set_has_operation_summary_result();
  operation_summary_result_ = value;
}

// -------------------------------------------------------------------

// AddSerializationJobCommand

// optional .Impinj.STP.SerializationJob serialization_job = 1;
inline bool AddSerializationJobCommand::has_serialization_job() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void AddSerializationJobCommand::set_has_serialization_job() {
  _has_bits_[0] |= 0x00000001u;
}
inline void AddSerializationJobCommand::clear_has_serialization_job() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void AddSerializationJobCommand::clear_serialization_job() {
  if (serialization_job_ != NULL) serialization_job_->::Impinj::STP::SerializationJob::Clear();
  clear_has_serialization_job();
}
inline const ::Impinj::STP::SerializationJob& AddSerializationJobCommand::serialization_job() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return serialization_job_ != NULL ? *serialization_job_ : *default_instance().serialization_job_;
#else
  return serialization_job_ != NULL ? *serialization_job_ : *default_instance_->serialization_job_;
#endif
}
inline ::Impinj::STP::SerializationJob* AddSerializationJobCommand::mutable_serialization_job() {
  set_has_serialization_job();
  if (serialization_job_ == NULL) serialization_job_ = new ::Impinj::STP::SerializationJob;
  return serialization_job_;
}
inline ::Impinj::STP::SerializationJob* AddSerializationJobCommand::release_serialization_job() {
  clear_has_serialization_job();
  ::Impinj::STP::SerializationJob* temp = serialization_job_;
  serialization_job_ = NULL;
  return temp;
}
inline void AddSerializationJobCommand::set_allocated_serialization_job(::Impinj::STP::SerializationJob* serialization_job) {
  delete serialization_job_;
  serialization_job_ = serialization_job;
  if (serialization_job) {
    set_has_serialization_job();
  } else {
    clear_has_serialization_job();
  }
}

// -------------------------------------------------------------------

// RemoveSerializationJobCommand

// optional uint32 job_id = 1;
inline bool RemoveSerializationJobCommand::has_job_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void RemoveSerializationJobCommand::set_has_job_id() {
  _has_bits_[0] |= 0x00000001u;
}
inline void RemoveSerializationJobCommand::clear_has_job_id() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void RemoveSerializationJobCommand::clear_job_id() {
  job_id_ = 0u;
  clear_has_job_id();
}
inline ::google::protobuf::uint32 RemoveSerializationJobCommand::job_id() const {
  return job_id_;
}
inline void RemoveSerializationJobCommand::set_job_id(::google::protobuf::uint32 value) {
  set_has_job_id();
  job_id_ = value;
}

// -------------------------------------------------------------------

// SetInventoryJobCommand

// optional .Impinj.STP.InventoryJob inventory_job = 1;
inline bool SetInventoryJobCommand::has_inventory_job() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void SetInventoryJobCommand::set_has_inventory_job() {
  _has_bits_[0] |= 0x00000001u;
}
inline void SetInventoryJobCommand::clear_has_inventory_job() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void SetInventoryJobCommand::clear_inventory_job() {
  if (inventory_job_ != NULL) inventory_job_->::Impinj::STP::InventoryJob::Clear();
  clear_has_inventory_job();
}
inline const ::Impinj::STP::InventoryJob& SetInventoryJobCommand::inventory_job() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return inventory_job_ != NULL ? *inventory_job_ : *default_instance().inventory_job_;
#else
  return inventory_job_ != NULL ? *inventory_job_ : *default_instance_->inventory_job_;
#endif
}
inline ::Impinj::STP::InventoryJob* SetInventoryJobCommand::mutable_inventory_job() {
  set_has_inventory_job();
  if (inventory_job_ == NULL) inventory_job_ = new ::Impinj::STP::InventoryJob;
  return inventory_job_;
}
inline ::Impinj::STP::InventoryJob* SetInventoryJobCommand::release_inventory_job() {
  clear_has_inventory_job();
  ::Impinj::STP::InventoryJob* temp = inventory_job_;
  inventory_job_ = NULL;
  return temp;
}
inline void SetInventoryJobCommand::set_allocated_inventory_job(::Impinj::STP::InventoryJob* inventory_job) {
  delete inventory_job_;
  inventory_job_ = inventory_job;
  if (inventory_job) {
    set_has_inventory_job();
  } else {
    clear_has_inventory_job();
  }
}

// -------------------------------------------------------------------

// SetCartonContentsJobCommand

// optional .Impinj.STP.CartonContentsJob carton_contents_job = 1;
inline bool SetCartonContentsJobCommand::has_carton_contents_job() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void SetCartonContentsJobCommand::set_has_carton_contents_job() {
  _has_bits_[0] |= 0x00000001u;
}
inline void SetCartonContentsJobCommand::clear_has_carton_contents_job() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void SetCartonContentsJobCommand::clear_carton_contents_job() {
  if (carton_contents_job_ != NULL) carton_contents_job_->::Impinj::STP::CartonContentsJob::Clear();
  clear_has_carton_contents_job();
}
inline const ::Impinj::STP::CartonContentsJob& SetCartonContentsJobCommand::carton_contents_job() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return carton_contents_job_ != NULL ? *carton_contents_job_ : *default_instance().carton_contents_job_;
#else
  return carton_contents_job_ != NULL ? *carton_contents_job_ : *default_instance_->carton_contents_job_;
#endif
}
inline ::Impinj::STP::CartonContentsJob* SetCartonContentsJobCommand::mutable_carton_contents_job() {
  set_has_carton_contents_job();
  if (carton_contents_job_ == NULL) carton_contents_job_ = new ::Impinj::STP::CartonContentsJob;
  return carton_contents_job_;
}
inline ::Impinj::STP::CartonContentsJob* SetCartonContentsJobCommand::release_carton_contents_job() {
  clear_has_carton_contents_job();
  ::Impinj::STP::CartonContentsJob* temp = carton_contents_job_;
  carton_contents_job_ = NULL;
  return temp;
}
inline void SetCartonContentsJobCommand::set_allocated_carton_contents_job(::Impinj::STP::CartonContentsJob* carton_contents_job) {
  delete carton_contents_job_;
  carton_contents_job_ = carton_contents_job;
  if (carton_contents_job) {
    set_has_carton_contents_job();
  } else {
    clear_has_carton_contents_job();
  }
}

// -------------------------------------------------------------------

// GetOperationDataCommand

// optional bool reserved = 1;
inline bool GetOperationDataCommand::has_reserved() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GetOperationDataCommand::set_has_reserved() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GetOperationDataCommand::clear_has_reserved() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GetOperationDataCommand::clear_reserved() {
  reserved_ = false;
  clear_has_reserved();
}
inline bool GetOperationDataCommand::reserved() const {
  return reserved_;
}
inline void GetOperationDataCommand::set_reserved(bool value) {
  set_has_reserved();
  reserved_ = value;
}

// -------------------------------------------------------------------

// AddLicenseKeyCommand

// optional .Impinj.STP.LicenseKey license_key = 1;
inline bool AddLicenseKeyCommand::has_license_key() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void AddLicenseKeyCommand::set_has_license_key() {
  _has_bits_[0] |= 0x00000001u;
}
inline void AddLicenseKeyCommand::clear_has_license_key() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void AddLicenseKeyCommand::clear_license_key() {
  if (license_key_ != NULL) license_key_->::Impinj::STP::LicenseKey::Clear();
  clear_has_license_key();
}
inline const ::Impinj::STP::LicenseKey& AddLicenseKeyCommand::license_key() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return license_key_ != NULL ? *license_key_ : *default_instance().license_key_;
#else
  return license_key_ != NULL ? *license_key_ : *default_instance_->license_key_;
#endif
}
inline ::Impinj::STP::LicenseKey* AddLicenseKeyCommand::mutable_license_key() {
  set_has_license_key();
  if (license_key_ == NULL) license_key_ = new ::Impinj::STP::LicenseKey;
  return license_key_;
}
inline ::Impinj::STP::LicenseKey* AddLicenseKeyCommand::release_license_key() {
  clear_has_license_key();
  ::Impinj::STP::LicenseKey* temp = license_key_;
  license_key_ = NULL;
  return temp;
}
inline void AddLicenseKeyCommand::set_allocated_license_key(::Impinj::STP::LicenseKey* license_key) {
  delete license_key_;
  license_key_ = license_key;
  if (license_key) {
    set_has_license_key();
  } else {
    clear_has_license_key();
  }
}

// -------------------------------------------------------------------

// AddTIDTableEntriesCommand

// optional .Impinj.STP.TIDTableEntries table_entries = 1;
inline bool AddTIDTableEntriesCommand::has_table_entries() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void AddTIDTableEntriesCommand::set_has_table_entries() {
  _has_bits_[0] |= 0x00000001u;
}
inline void AddTIDTableEntriesCommand::clear_has_table_entries() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void AddTIDTableEntriesCommand::clear_table_entries() {
  if (table_entries_ != NULL) table_entries_->::Impinj::STP::TIDTableEntries::Clear();
  clear_has_table_entries();
}
inline const ::Impinj::STP::TIDTableEntries& AddTIDTableEntriesCommand::table_entries() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return table_entries_ != NULL ? *table_entries_ : *default_instance().table_entries_;
#else
  return table_entries_ != NULL ? *table_entries_ : *default_instance_->table_entries_;
#endif
}
inline ::Impinj::STP::TIDTableEntries* AddTIDTableEntriesCommand::mutable_table_entries() {
  set_has_table_entries();
  if (table_entries_ == NULL) table_entries_ = new ::Impinj::STP::TIDTableEntries;
  return table_entries_;
}
inline ::Impinj::STP::TIDTableEntries* AddTIDTableEntriesCommand::release_table_entries() {
  clear_has_table_entries();
  ::Impinj::STP::TIDTableEntries* temp = table_entries_;
  table_entries_ = NULL;
  return temp;
}
inline void AddTIDTableEntriesCommand::set_allocated_table_entries(::Impinj::STP::TIDTableEntries* table_entries) {
  delete table_entries_;
  table_entries_ = table_entries;
  if (table_entries) {
    set_has_table_entries();
  } else {
    clear_has_table_entries();
  }
}

// -------------------------------------------------------------------

// AddOrderedListEntriesCommand

// optional .Impinj.STP.OrderedListEntries ordered_list_entries = 1;
inline bool AddOrderedListEntriesCommand::has_ordered_list_entries() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void AddOrderedListEntriesCommand::set_has_ordered_list_entries() {
  _has_bits_[0] |= 0x00000001u;
}
inline void AddOrderedListEntriesCommand::clear_has_ordered_list_entries() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void AddOrderedListEntriesCommand::clear_ordered_list_entries() {
  if (ordered_list_entries_ != NULL) ordered_list_entries_->::Impinj::STP::OrderedListEntries::Clear();
  clear_has_ordered_list_entries();
}
inline const ::Impinj::STP::OrderedListEntries& AddOrderedListEntriesCommand::ordered_list_entries() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return ordered_list_entries_ != NULL ? *ordered_list_entries_ : *default_instance().ordered_list_entries_;
#else
  return ordered_list_entries_ != NULL ? *ordered_list_entries_ : *default_instance_->ordered_list_entries_;
#endif
}
inline ::Impinj::STP::OrderedListEntries* AddOrderedListEntriesCommand::mutable_ordered_list_entries() {
  set_has_ordered_list_entries();
  if (ordered_list_entries_ == NULL) ordered_list_entries_ = new ::Impinj::STP::OrderedListEntries;
  return ordered_list_entries_;
}
inline ::Impinj::STP::OrderedListEntries* AddOrderedListEntriesCommand::release_ordered_list_entries() {
  clear_has_ordered_list_entries();
  ::Impinj::STP::OrderedListEntries* temp = ordered_list_entries_;
  ordered_list_entries_ = NULL;
  return temp;
}
inline void AddOrderedListEntriesCommand::set_allocated_ordered_list_entries(::Impinj::STP::OrderedListEntries* ordered_list_entries) {
  delete ordered_list_entries_;
  ordered_list_entries_ = ordered_list_entries;
  if (ordered_list_entries) {
    set_has_ordered_list_entries();
  } else {
    clear_has_ordered_list_entries();
  }
}

// -------------------------------------------------------------------

// StartResp

// optional .Impinj.STP.Reply reply = 1;
inline bool StartResp::has_reply() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void StartResp::set_has_reply() {
  _has_bits_[0] |= 0x00000001u;
}
inline void StartResp::clear_has_reply() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void StartResp::clear_reply() {
  if (reply_ != NULL) reply_->::Impinj::STP::Reply::Clear();
  clear_has_reply();
}
inline const ::Impinj::STP::Reply& StartResp::reply() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return reply_ != NULL ? *reply_ : *default_instance().reply_;
#else
  return reply_ != NULL ? *reply_ : *default_instance_->reply_;
#endif
}
inline ::Impinj::STP::Reply* StartResp::mutable_reply() {
  set_has_reply();
  if (reply_ == NULL) reply_ = new ::Impinj::STP::Reply;
  return reply_;
}
inline ::Impinj::STP::Reply* StartResp::release_reply() {
  clear_has_reply();
  ::Impinj::STP::Reply* temp = reply_;
  reply_ = NULL;
  return temp;
}
inline void StartResp::set_allocated_reply(::Impinj::STP::Reply* reply) {
  delete reply_;
  reply_ = reply;
  if (reply) {
    set_has_reply();
  } else {
    clear_has_reply();
  }
}

// -------------------------------------------------------------------

// SetDeviceConfigResp

// optional .Impinj.STP.Reply reply = 1;
inline bool SetDeviceConfigResp::has_reply() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void SetDeviceConfigResp::set_has_reply() {
  _has_bits_[0] |= 0x00000001u;
}
inline void SetDeviceConfigResp::clear_has_reply() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void SetDeviceConfigResp::clear_reply() {
  if (reply_ != NULL) reply_->::Impinj::STP::Reply::Clear();
  clear_has_reply();
}
inline const ::Impinj::STP::Reply& SetDeviceConfigResp::reply() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return reply_ != NULL ? *reply_ : *default_instance().reply_;
#else
  return reply_ != NULL ? *reply_ : *default_instance_->reply_;
#endif
}
inline ::Impinj::STP::Reply* SetDeviceConfigResp::mutable_reply() {
  set_has_reply();
  if (reply_ == NULL) reply_ = new ::Impinj::STP::Reply;
  return reply_;
}
inline ::Impinj::STP::Reply* SetDeviceConfigResp::release_reply() {
  clear_has_reply();
  ::Impinj::STP::Reply* temp = reply_;
  reply_ = NULL;
  return temp;
}
inline void SetDeviceConfigResp::set_allocated_reply(::Impinj::STP::Reply* reply) {
  delete reply_;
  reply_ = reply;
  if (reply) {
    set_has_reply();
  } else {
    clear_has_reply();
  }
}

// -------------------------------------------------------------------

// GetDeviceConfigResp

// optional .Impinj.STP.Reply reply = 1;
inline bool GetDeviceConfigResp::has_reply() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GetDeviceConfigResp::set_has_reply() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GetDeviceConfigResp::clear_has_reply() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GetDeviceConfigResp::clear_reply() {
  if (reply_ != NULL) reply_->::Impinj::STP::Reply::Clear();
  clear_has_reply();
}
inline const ::Impinj::STP::Reply& GetDeviceConfigResp::reply() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return reply_ != NULL ? *reply_ : *default_instance().reply_;
#else
  return reply_ != NULL ? *reply_ : *default_instance_->reply_;
#endif
}
inline ::Impinj::STP::Reply* GetDeviceConfigResp::mutable_reply() {
  set_has_reply();
  if (reply_ == NULL) reply_ = new ::Impinj::STP::Reply;
  return reply_;
}
inline ::Impinj::STP::Reply* GetDeviceConfigResp::release_reply() {
  clear_has_reply();
  ::Impinj::STP::Reply* temp = reply_;
  reply_ = NULL;
  return temp;
}
inline void GetDeviceConfigResp::set_allocated_reply(::Impinj::STP::Reply* reply) {
  delete reply_;
  reply_ = reply;
  if (reply) {
    set_has_reply();
  } else {
    clear_has_reply();
  }
}

// optional .Impinj.STP.DeviceConfig device_config = 2;
inline bool GetDeviceConfigResp::has_device_config() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void GetDeviceConfigResp::set_has_device_config() {
  _has_bits_[0] |= 0x00000002u;
}
inline void GetDeviceConfigResp::clear_has_device_config() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void GetDeviceConfigResp::clear_device_config() {
  if (device_config_ != NULL) device_config_->::Impinj::STP::DeviceConfig::Clear();
  clear_has_device_config();
}
inline const ::Impinj::STP::DeviceConfig& GetDeviceConfigResp::device_config() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return device_config_ != NULL ? *device_config_ : *default_instance().device_config_;
#else
  return device_config_ != NULL ? *device_config_ : *default_instance_->device_config_;
#endif
}
inline ::Impinj::STP::DeviceConfig* GetDeviceConfigResp::mutable_device_config() {
  set_has_device_config();
  if (device_config_ == NULL) device_config_ = new ::Impinj::STP::DeviceConfig;
  return device_config_;
}
inline ::Impinj::STP::DeviceConfig* GetDeviceConfigResp::release_device_config() {
  clear_has_device_config();
  ::Impinj::STP::DeviceConfig* temp = device_config_;
  device_config_ = NULL;
  return temp;
}
inline void GetDeviceConfigResp::set_allocated_device_config(::Impinj::STP::DeviceConfig* device_config) {
  delete device_config_;
  device_config_ = device_config;
  if (device_config) {
    set_has_device_config();
  } else {
    clear_has_device_config();
  }
}

// -------------------------------------------------------------------

// SetAntennaConfigResp

// optional .Impinj.STP.Reply reply = 1;
inline bool SetAntennaConfigResp::has_reply() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void SetAntennaConfigResp::set_has_reply() {
  _has_bits_[0] |= 0x00000001u;
}
inline void SetAntennaConfigResp::clear_has_reply() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void SetAntennaConfigResp::clear_reply() {
  if (reply_ != NULL) reply_->::Impinj::STP::Reply::Clear();
  clear_has_reply();
}
inline const ::Impinj::STP::Reply& SetAntennaConfigResp::reply() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return reply_ != NULL ? *reply_ : *default_instance().reply_;
#else
  return reply_ != NULL ? *reply_ : *default_instance_->reply_;
#endif
}
inline ::Impinj::STP::Reply* SetAntennaConfigResp::mutable_reply() {
  set_has_reply();
  if (reply_ == NULL) reply_ = new ::Impinj::STP::Reply;
  return reply_;
}
inline ::Impinj::STP::Reply* SetAntennaConfigResp::release_reply() {
  clear_has_reply();
  ::Impinj::STP::Reply* temp = reply_;
  reply_ = NULL;
  return temp;
}
inline void SetAntennaConfigResp::set_allocated_reply(::Impinj::STP::Reply* reply) {
  delete reply_;
  reply_ = reply;
  if (reply) {
    set_has_reply();
  } else {
    clear_has_reply();
  }
}

// -------------------------------------------------------------------

// GetAntennaConfigResp

// optional .Impinj.STP.Reply reply = 1;
inline bool GetAntennaConfigResp::has_reply() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GetAntennaConfigResp::set_has_reply() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GetAntennaConfigResp::clear_has_reply() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GetAntennaConfigResp::clear_reply() {
  if (reply_ != NULL) reply_->::Impinj::STP::Reply::Clear();
  clear_has_reply();
}
inline const ::Impinj::STP::Reply& GetAntennaConfigResp::reply() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return reply_ != NULL ? *reply_ : *default_instance().reply_;
#else
  return reply_ != NULL ? *reply_ : *default_instance_->reply_;
#endif
}
inline ::Impinj::STP::Reply* GetAntennaConfigResp::mutable_reply() {
  set_has_reply();
  if (reply_ == NULL) reply_ = new ::Impinj::STP::Reply;
  return reply_;
}
inline ::Impinj::STP::Reply* GetAntennaConfigResp::release_reply() {
  clear_has_reply();
  ::Impinj::STP::Reply* temp = reply_;
  reply_ = NULL;
  return temp;
}
inline void GetAntennaConfigResp::set_allocated_reply(::Impinj::STP::Reply* reply) {
  delete reply_;
  reply_ = reply;
  if (reply) {
    set_has_reply();
  } else {
    clear_has_reply();
  }
}

// optional .Impinj.STP.AntennasConfig antennas_config = 2;
inline bool GetAntennaConfigResp::has_antennas_config() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void GetAntennaConfigResp::set_has_antennas_config() {
  _has_bits_[0] |= 0x00000002u;
}
inline void GetAntennaConfigResp::clear_has_antennas_config() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void GetAntennaConfigResp::clear_antennas_config() {
  if (antennas_config_ != NULL) antennas_config_->::Impinj::STP::AntennasConfig::Clear();
  clear_has_antennas_config();
}
inline const ::Impinj::STP::AntennasConfig& GetAntennaConfigResp::antennas_config() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return antennas_config_ != NULL ? *antennas_config_ : *default_instance().antennas_config_;
#else
  return antennas_config_ != NULL ? *antennas_config_ : *default_instance_->antennas_config_;
#endif
}
inline ::Impinj::STP::AntennasConfig* GetAntennaConfigResp::mutable_antennas_config() {
  set_has_antennas_config();
  if (antennas_config_ == NULL) antennas_config_ = new ::Impinj::STP::AntennasConfig;
  return antennas_config_;
}
inline ::Impinj::STP::AntennasConfig* GetAntennaConfigResp::release_antennas_config() {
  clear_has_antennas_config();
  ::Impinj::STP::AntennasConfig* temp = antennas_config_;
  antennas_config_ = NULL;
  return temp;
}
inline void GetAntennaConfigResp::set_allocated_antennas_config(::Impinj::STP::AntennasConfig* antennas_config) {
  delete antennas_config_;
  antennas_config_ = antennas_config;
  if (antennas_config) {
    set_has_antennas_config();
  } else {
    clear_has_antennas_config();
  }
}

// -------------------------------------------------------------------

// EngageResp

// optional .Impinj.STP.Reply reply = 1;
inline bool EngageResp::has_reply() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void EngageResp::set_has_reply() {
  _has_bits_[0] |= 0x00000001u;
}
inline void EngageResp::clear_has_reply() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void EngageResp::clear_reply() {
  if (reply_ != NULL) reply_->::Impinj::STP::Reply::Clear();
  clear_has_reply();
}
inline const ::Impinj::STP::Reply& EngageResp::reply() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return reply_ != NULL ? *reply_ : *default_instance().reply_;
#else
  return reply_ != NULL ? *reply_ : *default_instance_->reply_;
#endif
}
inline ::Impinj::STP::Reply* EngageResp::mutable_reply() {
  set_has_reply();
  if (reply_ == NULL) reply_ = new ::Impinj::STP::Reply;
  return reply_;
}
inline ::Impinj::STP::Reply* EngageResp::release_reply() {
  clear_has_reply();
  ::Impinj::STP::Reply* temp = reply_;
  reply_ = NULL;
  return temp;
}
inline void EngageResp::set_allocated_reply(::Impinj::STP::Reply* reply) {
  delete reply_;
  reply_ = reply;
  if (reply) {
    set_has_reply();
  } else {
    clear_has_reply();
  }
}

// -------------------------------------------------------------------

// DisengageResp

// optional .Impinj.STP.Reply reply = 1;
inline bool DisengageResp::has_reply() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void DisengageResp::set_has_reply() {
  _has_bits_[0] |= 0x00000001u;
}
inline void DisengageResp::clear_has_reply() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void DisengageResp::clear_reply() {
  if (reply_ != NULL) reply_->::Impinj::STP::Reply::Clear();
  clear_has_reply();
}
inline const ::Impinj::STP::Reply& DisengageResp::reply() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return reply_ != NULL ? *reply_ : *default_instance().reply_;
#else
  return reply_ != NULL ? *reply_ : *default_instance_->reply_;
#endif
}
inline ::Impinj::STP::Reply* DisengageResp::mutable_reply() {
  set_has_reply();
  if (reply_ == NULL) reply_ = new ::Impinj::STP::Reply;
  return reply_;
}
inline ::Impinj::STP::Reply* DisengageResp::release_reply() {
  clear_has_reply();
  ::Impinj::STP::Reply* temp = reply_;
  reply_ = NULL;
  return temp;
}
inline void DisengageResp::set_allocated_reply(::Impinj::STP::Reply* reply) {
  delete reply_;
  reply_ = reply;
  if (reply) {
    set_has_reply();
  } else {
    clear_has_reply();
  }
}

// -------------------------------------------------------------------

// SetOperationResultGPOResp

// optional .Impinj.STP.Reply reply = 1;
inline bool SetOperationResultGPOResp::has_reply() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void SetOperationResultGPOResp::set_has_reply() {
  _has_bits_[0] |= 0x00000001u;
}
inline void SetOperationResultGPOResp::clear_has_reply() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void SetOperationResultGPOResp::clear_reply() {
  if (reply_ != NULL) reply_->::Impinj::STP::Reply::Clear();
  clear_has_reply();
}
inline const ::Impinj::STP::Reply& SetOperationResultGPOResp::reply() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return reply_ != NULL ? *reply_ : *default_instance().reply_;
#else
  return reply_ != NULL ? *reply_ : *default_instance_->reply_;
#endif
}
inline ::Impinj::STP::Reply* SetOperationResultGPOResp::mutable_reply() {
  set_has_reply();
  if (reply_ == NULL) reply_ = new ::Impinj::STP::Reply;
  return reply_;
}
inline ::Impinj::STP::Reply* SetOperationResultGPOResp::release_reply() {
  clear_has_reply();
  ::Impinj::STP::Reply* temp = reply_;
  reply_ = NULL;
  return temp;
}
inline void SetOperationResultGPOResp::set_allocated_reply(::Impinj::STP::Reply* reply) {
  delete reply_;
  reply_ = reply;
  if (reply) {
    set_has_reply();
  } else {
    clear_has_reply();
  }
}

// -------------------------------------------------------------------

// AddSerializationJobResp

// optional .Impinj.STP.Reply reply = 1;
inline bool AddSerializationJobResp::has_reply() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void AddSerializationJobResp::set_has_reply() {
  _has_bits_[0] |= 0x00000001u;
}
inline void AddSerializationJobResp::clear_has_reply() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void AddSerializationJobResp::clear_reply() {
  if (reply_ != NULL) reply_->::Impinj::STP::Reply::Clear();
  clear_has_reply();
}
inline const ::Impinj::STP::Reply& AddSerializationJobResp::reply() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return reply_ != NULL ? *reply_ : *default_instance().reply_;
#else
  return reply_ != NULL ? *reply_ : *default_instance_->reply_;
#endif
}
inline ::Impinj::STP::Reply* AddSerializationJobResp::mutable_reply() {
  set_has_reply();
  if (reply_ == NULL) reply_ = new ::Impinj::STP::Reply;
  return reply_;
}
inline ::Impinj::STP::Reply* AddSerializationJobResp::release_reply() {
  clear_has_reply();
  ::Impinj::STP::Reply* temp = reply_;
  reply_ = NULL;
  return temp;
}
inline void AddSerializationJobResp::set_allocated_reply(::Impinj::STP::Reply* reply) {
  delete reply_;
  reply_ = reply;
  if (reply) {
    set_has_reply();
  } else {
    clear_has_reply();
  }
}

// -------------------------------------------------------------------

// RemoveSerializationJobResp

// optional .Impinj.STP.Reply reply = 1;
inline bool RemoveSerializationJobResp::has_reply() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void RemoveSerializationJobResp::set_has_reply() {
  _has_bits_[0] |= 0x00000001u;
}
inline void RemoveSerializationJobResp::clear_has_reply() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void RemoveSerializationJobResp::clear_reply() {
  if (reply_ != NULL) reply_->::Impinj::STP::Reply::Clear();
  clear_has_reply();
}
inline const ::Impinj::STP::Reply& RemoveSerializationJobResp::reply() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return reply_ != NULL ? *reply_ : *default_instance().reply_;
#else
  return reply_ != NULL ? *reply_ : *default_instance_->reply_;
#endif
}
inline ::Impinj::STP::Reply* RemoveSerializationJobResp::mutable_reply() {
  set_has_reply();
  if (reply_ == NULL) reply_ = new ::Impinj::STP::Reply;
  return reply_;
}
inline ::Impinj::STP::Reply* RemoveSerializationJobResp::release_reply() {
  clear_has_reply();
  ::Impinj::STP::Reply* temp = reply_;
  reply_ = NULL;
  return temp;
}
inline void RemoveSerializationJobResp::set_allocated_reply(::Impinj::STP::Reply* reply) {
  delete reply_;
  reply_ = reply;
  if (reply) {
    set_has_reply();
  } else {
    clear_has_reply();
  }
}

// -------------------------------------------------------------------

// SetInventoryJobResp

// optional .Impinj.STP.Reply reply = 1;
inline bool SetInventoryJobResp::has_reply() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void SetInventoryJobResp::set_has_reply() {
  _has_bits_[0] |= 0x00000001u;
}
inline void SetInventoryJobResp::clear_has_reply() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void SetInventoryJobResp::clear_reply() {
  if (reply_ != NULL) reply_->::Impinj::STP::Reply::Clear();
  clear_has_reply();
}
inline const ::Impinj::STP::Reply& SetInventoryJobResp::reply() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return reply_ != NULL ? *reply_ : *default_instance().reply_;
#else
  return reply_ != NULL ? *reply_ : *default_instance_->reply_;
#endif
}
inline ::Impinj::STP::Reply* SetInventoryJobResp::mutable_reply() {
  set_has_reply();
  if (reply_ == NULL) reply_ = new ::Impinj::STP::Reply;
  return reply_;
}
inline ::Impinj::STP::Reply* SetInventoryJobResp::release_reply() {
  clear_has_reply();
  ::Impinj::STP::Reply* temp = reply_;
  reply_ = NULL;
  return temp;
}
inline void SetInventoryJobResp::set_allocated_reply(::Impinj::STP::Reply* reply) {
  delete reply_;
  reply_ = reply;
  if (reply) {
    set_has_reply();
  } else {
    clear_has_reply();
  }
}

// -------------------------------------------------------------------

// SetCartonContentsJobResp

// optional .Impinj.STP.Reply reply = 1;
inline bool SetCartonContentsJobResp::has_reply() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void SetCartonContentsJobResp::set_has_reply() {
  _has_bits_[0] |= 0x00000001u;
}
inline void SetCartonContentsJobResp::clear_has_reply() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void SetCartonContentsJobResp::clear_reply() {
  if (reply_ != NULL) reply_->::Impinj::STP::Reply::Clear();
  clear_has_reply();
}
inline const ::Impinj::STP::Reply& SetCartonContentsJobResp::reply() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return reply_ != NULL ? *reply_ : *default_instance().reply_;
#else
  return reply_ != NULL ? *reply_ : *default_instance_->reply_;
#endif
}
inline ::Impinj::STP::Reply* SetCartonContentsJobResp::mutable_reply() {
  set_has_reply();
  if (reply_ == NULL) reply_ = new ::Impinj::STP::Reply;
  return reply_;
}
inline ::Impinj::STP::Reply* SetCartonContentsJobResp::release_reply() {
  clear_has_reply();
  ::Impinj::STP::Reply* temp = reply_;
  reply_ = NULL;
  return temp;
}
inline void SetCartonContentsJobResp::set_allocated_reply(::Impinj::STP::Reply* reply) {
  delete reply_;
  reply_ = reply;
  if (reply) {
    set_has_reply();
  } else {
    clear_has_reply();
  }
}

// -------------------------------------------------------------------

// GetOperationDataResp

// optional .Impinj.STP.Reply reply = 1;
inline bool GetOperationDataResp::has_reply() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GetOperationDataResp::set_has_reply() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GetOperationDataResp::clear_has_reply() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GetOperationDataResp::clear_reply() {
  if (reply_ != NULL) reply_->::Impinj::STP::Reply::Clear();
  clear_has_reply();
}
inline const ::Impinj::STP::Reply& GetOperationDataResp::reply() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return reply_ != NULL ? *reply_ : *default_instance().reply_;
#else
  return reply_ != NULL ? *reply_ : *default_instance_->reply_;
#endif
}
inline ::Impinj::STP::Reply* GetOperationDataResp::mutable_reply() {
  set_has_reply();
  if (reply_ == NULL) reply_ = new ::Impinj::STP::Reply;
  return reply_;
}
inline ::Impinj::STP::Reply* GetOperationDataResp::release_reply() {
  clear_has_reply();
  ::Impinj::STP::Reply* temp = reply_;
  reply_ = NULL;
  return temp;
}
inline void GetOperationDataResp::set_allocated_reply(::Impinj::STP::Reply* reply) {
  delete reply_;
  reply_ = reply;
  if (reply) {
    set_has_reply();
  } else {
    clear_has_reply();
  }
}

// optional .Impinj.STP.OperationData operation_data = 2;
inline bool GetOperationDataResp::has_operation_data() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void GetOperationDataResp::set_has_operation_data() {
  _has_bits_[0] |= 0x00000002u;
}
inline void GetOperationDataResp::clear_has_operation_data() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void GetOperationDataResp::clear_operation_data() {
  if (operation_data_ != NULL) operation_data_->::Impinj::STP::OperationData::Clear();
  clear_has_operation_data();
}
inline const ::Impinj::STP::OperationData& GetOperationDataResp::operation_data() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return operation_data_ != NULL ? *operation_data_ : *default_instance().operation_data_;
#else
  return operation_data_ != NULL ? *operation_data_ : *default_instance_->operation_data_;
#endif
}
inline ::Impinj::STP::OperationData* GetOperationDataResp::mutable_operation_data() {
  set_has_operation_data();
  if (operation_data_ == NULL) operation_data_ = new ::Impinj::STP::OperationData;
  return operation_data_;
}
inline ::Impinj::STP::OperationData* GetOperationDataResp::release_operation_data() {
  clear_has_operation_data();
  ::Impinj::STP::OperationData* temp = operation_data_;
  operation_data_ = NULL;
  return temp;
}
inline void GetOperationDataResp::set_allocated_operation_data(::Impinj::STP::OperationData* operation_data) {
  delete operation_data_;
  operation_data_ = operation_data;
  if (operation_data) {
    set_has_operation_data();
  } else {
    clear_has_operation_data();
  }
}

// -------------------------------------------------------------------

// AddLicenseKeyResp

// optional .Impinj.STP.Reply reply = 1;
inline bool AddLicenseKeyResp::has_reply() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void AddLicenseKeyResp::set_has_reply() {
  _has_bits_[0] |= 0x00000001u;
}
inline void AddLicenseKeyResp::clear_has_reply() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void AddLicenseKeyResp::clear_reply() {
  if (reply_ != NULL) reply_->::Impinj::STP::Reply::Clear();
  clear_has_reply();
}
inline const ::Impinj::STP::Reply& AddLicenseKeyResp::reply() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return reply_ != NULL ? *reply_ : *default_instance().reply_;
#else
  return reply_ != NULL ? *reply_ : *default_instance_->reply_;
#endif
}
inline ::Impinj::STP::Reply* AddLicenseKeyResp::mutable_reply() {
  set_has_reply();
  if (reply_ == NULL) reply_ = new ::Impinj::STP::Reply;
  return reply_;
}
inline ::Impinj::STP::Reply* AddLicenseKeyResp::release_reply() {
  clear_has_reply();
  ::Impinj::STP::Reply* temp = reply_;
  reply_ = NULL;
  return temp;
}
inline void AddLicenseKeyResp::set_allocated_reply(::Impinj::STP::Reply* reply) {
  delete reply_;
  reply_ = reply;
  if (reply) {
    set_has_reply();
  } else {
    clear_has_reply();
  }
}

// -------------------------------------------------------------------

// AddTIDTableEntriesResp

// optional .Impinj.STP.Reply reply = 1;
inline bool AddTIDTableEntriesResp::has_reply() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void AddTIDTableEntriesResp::set_has_reply() {
  _has_bits_[0] |= 0x00000001u;
}
inline void AddTIDTableEntriesResp::clear_has_reply() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void AddTIDTableEntriesResp::clear_reply() {
  if (reply_ != NULL) reply_->::Impinj::STP::Reply::Clear();
  clear_has_reply();
}
inline const ::Impinj::STP::Reply& AddTIDTableEntriesResp::reply() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return reply_ != NULL ? *reply_ : *default_instance().reply_;
#else
  return reply_ != NULL ? *reply_ : *default_instance_->reply_;
#endif
}
inline ::Impinj::STP::Reply* AddTIDTableEntriesResp::mutable_reply() {
  set_has_reply();
  if (reply_ == NULL) reply_ = new ::Impinj::STP::Reply;
  return reply_;
}
inline ::Impinj::STP::Reply* AddTIDTableEntriesResp::release_reply() {
  clear_has_reply();
  ::Impinj::STP::Reply* temp = reply_;
  reply_ = NULL;
  return temp;
}
inline void AddTIDTableEntriesResp::set_allocated_reply(::Impinj::STP::Reply* reply) {
  delete reply_;
  reply_ = reply;
  if (reply) {
    set_has_reply();
  } else {
    clear_has_reply();
  }
}

// -------------------------------------------------------------------

// AddOrderedListEntriesResp

// optional .Impinj.STP.Reply reply = 1;
inline bool AddOrderedListEntriesResp::has_reply() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void AddOrderedListEntriesResp::set_has_reply() {
  _has_bits_[0] |= 0x00000001u;
}
inline void AddOrderedListEntriesResp::clear_has_reply() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void AddOrderedListEntriesResp::clear_reply() {
  if (reply_ != NULL) reply_->::Impinj::STP::Reply::Clear();
  clear_has_reply();
}
inline const ::Impinj::STP::Reply& AddOrderedListEntriesResp::reply() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return reply_ != NULL ? *reply_ : *default_instance().reply_;
#else
  return reply_ != NULL ? *reply_ : *default_instance_->reply_;
#endif
}
inline ::Impinj::STP::Reply* AddOrderedListEntriesResp::mutable_reply() {
  set_has_reply();
  if (reply_ == NULL) reply_ = new ::Impinj::STP::Reply;
  return reply_;
}
inline ::Impinj::STP::Reply* AddOrderedListEntriesResp::release_reply() {
  clear_has_reply();
  ::Impinj::STP::Reply* temp = reply_;
  reply_ = NULL;
  return temp;
}
inline void AddOrderedListEntriesResp::set_allocated_reply(::Impinj::STP::Reply* reply) {
  delete reply_;
  reply_ = reply;
  if (reply) {
    set_has_reply();
  } else {
    clear_has_reply();
  }
}

// -------------------------------------------------------------------

// Command

// optional .Impinj.STP.ConnectCommand connect = 1;
inline bool Command::has_connect() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Command::set_has_connect() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Command::clear_has_connect() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Command::clear_connect() {
  if (connect_ != NULL) connect_->::Impinj::STP::ConnectCommand::Clear();
  clear_has_connect();
}
inline const ::Impinj::STP::ConnectCommand& Command::connect() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return connect_ != NULL ? *connect_ : *default_instance().connect_;
#else
  return connect_ != NULL ? *connect_ : *default_instance_->connect_;
#endif
}
inline ::Impinj::STP::ConnectCommand* Command::mutable_connect() {
  set_has_connect();
  if (connect_ == NULL) connect_ = new ::Impinj::STP::ConnectCommand;
  return connect_;
}
inline ::Impinj::STP::ConnectCommand* Command::release_connect() {
  clear_has_connect();
  ::Impinj::STP::ConnectCommand* temp = connect_;
  connect_ = NULL;
  return temp;
}
inline void Command::set_allocated_connect(::Impinj::STP::ConnectCommand* connect) {
  delete connect_;
  connect_ = connect;
  if (connect) {
    set_has_connect();
  } else {
    clear_has_connect();
  }
}

// optional .Impinj.STP.GetVersionsReaderCommand get_versions_reader = 2;
inline bool Command::has_get_versions_reader() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void Command::set_has_get_versions_reader() {
  _has_bits_[0] |= 0x00000002u;
}
inline void Command::clear_has_get_versions_reader() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void Command::clear_get_versions_reader() {
  if (get_versions_reader_ != NULL) get_versions_reader_->::Impinj::STP::GetVersionsReaderCommand::Clear();
  clear_has_get_versions_reader();
}
inline const ::Impinj::STP::GetVersionsReaderCommand& Command::get_versions_reader() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return get_versions_reader_ != NULL ? *get_versions_reader_ : *default_instance().get_versions_reader_;
#else
  return get_versions_reader_ != NULL ? *get_versions_reader_ : *default_instance_->get_versions_reader_;
#endif
}
inline ::Impinj::STP::GetVersionsReaderCommand* Command::mutable_get_versions_reader() {
  set_has_get_versions_reader();
  if (get_versions_reader_ == NULL) get_versions_reader_ = new ::Impinj::STP::GetVersionsReaderCommand;
  return get_versions_reader_;
}
inline ::Impinj::STP::GetVersionsReaderCommand* Command::release_get_versions_reader() {
  clear_has_get_versions_reader();
  ::Impinj::STP::GetVersionsReaderCommand* temp = get_versions_reader_;
  get_versions_reader_ = NULL;
  return temp;
}
inline void Command::set_allocated_get_versions_reader(::Impinj::STP::GetVersionsReaderCommand* get_versions_reader) {
  delete get_versions_reader_;
  get_versions_reader_ = get_versions_reader;
  if (get_versions_reader) {
    set_has_get_versions_reader();
  } else {
    clear_has_get_versions_reader();
  }
}

// optional .Impinj.STP.StartCommand start = 7;
inline bool Command::has_start() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void Command::set_has_start() {
  _has_bits_[0] |= 0x00000004u;
}
inline void Command::clear_has_start() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void Command::clear_start() {
  if (start_ != NULL) start_->::Impinj::STP::StartCommand::Clear();
  clear_has_start();
}
inline const ::Impinj::STP::StartCommand& Command::start() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return start_ != NULL ? *start_ : *default_instance().start_;
#else
  return start_ != NULL ? *start_ : *default_instance_->start_;
#endif
}
inline ::Impinj::STP::StartCommand* Command::mutable_start() {
  set_has_start();
  if (start_ == NULL) start_ = new ::Impinj::STP::StartCommand;
  return start_;
}
inline ::Impinj::STP::StartCommand* Command::release_start() {
  clear_has_start();
  ::Impinj::STP::StartCommand* temp = start_;
  start_ = NULL;
  return temp;
}
inline void Command::set_allocated_start(::Impinj::STP::StartCommand* start) {
  delete start_;
  start_ = start;
  if (start) {
    set_has_start();
  } else {
    clear_has_start();
  }
}

// optional .Impinj.STP.StopCommand stop = 8;
inline bool Command::has_stop() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void Command::set_has_stop() {
  _has_bits_[0] |= 0x00000008u;
}
inline void Command::clear_has_stop() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void Command::clear_stop() {
  if (stop_ != NULL) stop_->::Impinj::STP::StopCommand::Clear();
  clear_has_stop();
}
inline const ::Impinj::STP::StopCommand& Command::stop() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return stop_ != NULL ? *stop_ : *default_instance().stop_;
#else
  return stop_ != NULL ? *stop_ : *default_instance_->stop_;
#endif
}
inline ::Impinj::STP::StopCommand* Command::mutable_stop() {
  set_has_stop();
  if (stop_ == NULL) stop_ = new ::Impinj::STP::StopCommand;
  return stop_;
}
inline ::Impinj::STP::StopCommand* Command::release_stop() {
  clear_has_stop();
  ::Impinj::STP::StopCommand* temp = stop_;
  stop_ = NULL;
  return temp;
}
inline void Command::set_allocated_stop(::Impinj::STP::StopCommand* stop) {
  delete stop_;
  stop_ = stop;
  if (stop) {
    set_has_stop();
  } else {
    clear_has_stop();
  }
}

// optional .Impinj.STP.GetDeviceStateCommand get_device_state = 25;
inline bool Command::has_get_device_state() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void Command::set_has_get_device_state() {
  _has_bits_[0] |= 0x00000010u;
}
inline void Command::clear_has_get_device_state() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void Command::clear_get_device_state() {
  if (get_device_state_ != NULL) get_device_state_->::Impinj::STP::GetDeviceStateCommand::Clear();
  clear_has_get_device_state();
}
inline const ::Impinj::STP::GetDeviceStateCommand& Command::get_device_state() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return get_device_state_ != NULL ? *get_device_state_ : *default_instance().get_device_state_;
#else
  return get_device_state_ != NULL ? *get_device_state_ : *default_instance_->get_device_state_;
#endif
}
inline ::Impinj::STP::GetDeviceStateCommand* Command::mutable_get_device_state() {
  set_has_get_device_state();
  if (get_device_state_ == NULL) get_device_state_ = new ::Impinj::STP::GetDeviceStateCommand;
  return get_device_state_;
}
inline ::Impinj::STP::GetDeviceStateCommand* Command::release_get_device_state() {
  clear_has_get_device_state();
  ::Impinj::STP::GetDeviceStateCommand* temp = get_device_state_;
  get_device_state_ = NULL;
  return temp;
}
inline void Command::set_allocated_get_device_state(::Impinj::STP::GetDeviceStateCommand* get_device_state) {
  delete get_device_state_;
  get_device_state_ = get_device_state;
  if (get_device_state) {
    set_has_get_device_state();
  } else {
    clear_has_get_device_state();
  }
}

// optional .Impinj.STP.SetDeviceConfigCommand set_device_config = 12032;
inline bool Command::has_set_device_config() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void Command::set_has_set_device_config() {
  _has_bits_[0] |= 0x00000020u;
}
inline void Command::clear_has_set_device_config() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void Command::clear_set_device_config() {
  if (set_device_config_ != NULL) set_device_config_->::Impinj::STP::SetDeviceConfigCommand::Clear();
  clear_has_set_device_config();
}
inline const ::Impinj::STP::SetDeviceConfigCommand& Command::set_device_config() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return set_device_config_ != NULL ? *set_device_config_ : *default_instance().set_device_config_;
#else
  return set_device_config_ != NULL ? *set_device_config_ : *default_instance_->set_device_config_;
#endif
}
inline ::Impinj::STP::SetDeviceConfigCommand* Command::mutable_set_device_config() {
  set_has_set_device_config();
  if (set_device_config_ == NULL) set_device_config_ = new ::Impinj::STP::SetDeviceConfigCommand;
  return set_device_config_;
}
inline ::Impinj::STP::SetDeviceConfigCommand* Command::release_set_device_config() {
  clear_has_set_device_config();
  ::Impinj::STP::SetDeviceConfigCommand* temp = set_device_config_;
  set_device_config_ = NULL;
  return temp;
}
inline void Command::set_allocated_set_device_config(::Impinj::STP::SetDeviceConfigCommand* set_device_config) {
  delete set_device_config_;
  set_device_config_ = set_device_config;
  if (set_device_config) {
    set_has_set_device_config();
  } else {
    clear_has_set_device_config();
  }
}

// optional .Impinj.STP.GetDeviceConfigCommand get_device_config = 12033;
inline bool Command::has_get_device_config() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void Command::set_has_get_device_config() {
  _has_bits_[0] |= 0x00000040u;
}
inline void Command::clear_has_get_device_config() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void Command::clear_get_device_config() {
  if (get_device_config_ != NULL) get_device_config_->::Impinj::STP::GetDeviceConfigCommand::Clear();
  clear_has_get_device_config();
}
inline const ::Impinj::STP::GetDeviceConfigCommand& Command::get_device_config() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return get_device_config_ != NULL ? *get_device_config_ : *default_instance().get_device_config_;
#else
  return get_device_config_ != NULL ? *get_device_config_ : *default_instance_->get_device_config_;
#endif
}
inline ::Impinj::STP::GetDeviceConfigCommand* Command::mutable_get_device_config() {
  set_has_get_device_config();
  if (get_device_config_ == NULL) get_device_config_ = new ::Impinj::STP::GetDeviceConfigCommand;
  return get_device_config_;
}
inline ::Impinj::STP::GetDeviceConfigCommand* Command::release_get_device_config() {
  clear_has_get_device_config();
  ::Impinj::STP::GetDeviceConfigCommand* temp = get_device_config_;
  get_device_config_ = NULL;
  return temp;
}
inline void Command::set_allocated_get_device_config(::Impinj::STP::GetDeviceConfigCommand* get_device_config) {
  delete get_device_config_;
  get_device_config_ = get_device_config;
  if (get_device_config) {
    set_has_get_device_config();
  } else {
    clear_has_get_device_config();
  }
}

// optional .Impinj.STP.SetAntennaConfigCommand set_antenna_config = 12034;
inline bool Command::has_set_antenna_config() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void Command::set_has_set_antenna_config() {
  _has_bits_[0] |= 0x00000080u;
}
inline void Command::clear_has_set_antenna_config() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void Command::clear_set_antenna_config() {
  if (set_antenna_config_ != NULL) set_antenna_config_->::Impinj::STP::SetAntennaConfigCommand::Clear();
  clear_has_set_antenna_config();
}
inline const ::Impinj::STP::SetAntennaConfigCommand& Command::set_antenna_config() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return set_antenna_config_ != NULL ? *set_antenna_config_ : *default_instance().set_antenna_config_;
#else
  return set_antenna_config_ != NULL ? *set_antenna_config_ : *default_instance_->set_antenna_config_;
#endif
}
inline ::Impinj::STP::SetAntennaConfigCommand* Command::mutable_set_antenna_config() {
  set_has_set_antenna_config();
  if (set_antenna_config_ == NULL) set_antenna_config_ = new ::Impinj::STP::SetAntennaConfigCommand;
  return set_antenna_config_;
}
inline ::Impinj::STP::SetAntennaConfigCommand* Command::release_set_antenna_config() {
  clear_has_set_antenna_config();
  ::Impinj::STP::SetAntennaConfigCommand* temp = set_antenna_config_;
  set_antenna_config_ = NULL;
  return temp;
}
inline void Command::set_allocated_set_antenna_config(::Impinj::STP::SetAntennaConfigCommand* set_antenna_config) {
  delete set_antenna_config_;
  set_antenna_config_ = set_antenna_config;
  if (set_antenna_config) {
    set_has_set_antenna_config();
  } else {
    clear_has_set_antenna_config();
  }
}

// optional .Impinj.STP.GetAntennaConfigCommand get_antenna_config = 12035;
inline bool Command::has_get_antenna_config() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void Command::set_has_get_antenna_config() {
  _has_bits_[0] |= 0x00000100u;
}
inline void Command::clear_has_get_antenna_config() {
  _has_bits_[0] &= ~0x00000100u;
}
inline void Command::clear_get_antenna_config() {
  if (get_antenna_config_ != NULL) get_antenna_config_->::Impinj::STP::GetAntennaConfigCommand::Clear();
  clear_has_get_antenna_config();
}
inline const ::Impinj::STP::GetAntennaConfigCommand& Command::get_antenna_config() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return get_antenna_config_ != NULL ? *get_antenna_config_ : *default_instance().get_antenna_config_;
#else
  return get_antenna_config_ != NULL ? *get_antenna_config_ : *default_instance_->get_antenna_config_;
#endif
}
inline ::Impinj::STP::GetAntennaConfigCommand* Command::mutable_get_antenna_config() {
  set_has_get_antenna_config();
  if (get_antenna_config_ == NULL) get_antenna_config_ = new ::Impinj::STP::GetAntennaConfigCommand;
  return get_antenna_config_;
}
inline ::Impinj::STP::GetAntennaConfigCommand* Command::release_get_antenna_config() {
  clear_has_get_antenna_config();
  ::Impinj::STP::GetAntennaConfigCommand* temp = get_antenna_config_;
  get_antenna_config_ = NULL;
  return temp;
}
inline void Command::set_allocated_get_antenna_config(::Impinj::STP::GetAntennaConfigCommand* get_antenna_config) {
  delete get_antenna_config_;
  get_antenna_config_ = get_antenna_config;
  if (get_antenna_config) {
    set_has_get_antenna_config();
  } else {
    clear_has_get_antenna_config();
  }
}

// optional .Impinj.STP.EngageCommand engage = 12036;
inline bool Command::has_engage() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void Command::set_has_engage() {
  _has_bits_[0] |= 0x00000200u;
}
inline void Command::clear_has_engage() {
  _has_bits_[0] &= ~0x00000200u;
}
inline void Command::clear_engage() {
  if (engage_ != NULL) engage_->::Impinj::STP::EngageCommand::Clear();
  clear_has_engage();
}
inline const ::Impinj::STP::EngageCommand& Command::engage() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return engage_ != NULL ? *engage_ : *default_instance().engage_;
#else
  return engage_ != NULL ? *engage_ : *default_instance_->engage_;
#endif
}
inline ::Impinj::STP::EngageCommand* Command::mutable_engage() {
  set_has_engage();
  if (engage_ == NULL) engage_ = new ::Impinj::STP::EngageCommand;
  return engage_;
}
inline ::Impinj::STP::EngageCommand* Command::release_engage() {
  clear_has_engage();
  ::Impinj::STP::EngageCommand* temp = engage_;
  engage_ = NULL;
  return temp;
}
inline void Command::set_allocated_engage(::Impinj::STP::EngageCommand* engage) {
  delete engage_;
  engage_ = engage;
  if (engage) {
    set_has_engage();
  } else {
    clear_has_engage();
  }
}

// optional .Impinj.STP.DisengageCommand disengage = 12037;
inline bool Command::has_disengage() const {
  return (_has_bits_[0] & 0x00000400u) != 0;
}
inline void Command::set_has_disengage() {
  _has_bits_[0] |= 0x00000400u;
}
inline void Command::clear_has_disengage() {
  _has_bits_[0] &= ~0x00000400u;
}
inline void Command::clear_disengage() {
  if (disengage_ != NULL) disengage_->::Impinj::STP::DisengageCommand::Clear();
  clear_has_disengage();
}
inline const ::Impinj::STP::DisengageCommand& Command::disengage() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return disengage_ != NULL ? *disengage_ : *default_instance().disengage_;
#else
  return disengage_ != NULL ? *disengage_ : *default_instance_->disengage_;
#endif
}
inline ::Impinj::STP::DisengageCommand* Command::mutable_disengage() {
  set_has_disengage();
  if (disengage_ == NULL) disengage_ = new ::Impinj::STP::DisengageCommand;
  return disengage_;
}
inline ::Impinj::STP::DisengageCommand* Command::release_disengage() {
  clear_has_disengage();
  ::Impinj::STP::DisengageCommand* temp = disengage_;
  disengage_ = NULL;
  return temp;
}
inline void Command::set_allocated_disengage(::Impinj::STP::DisengageCommand* disengage) {
  delete disengage_;
  disengage_ = disengage;
  if (disengage) {
    set_has_disengage();
  } else {
    clear_has_disengage();
  }
}

// optional .Impinj.STP.SetOperationResultGPOCommand set_operation_result_gpo = 12038;
inline bool Command::has_set_operation_result_gpo() const {
  return (_has_bits_[0] & 0x00000800u) != 0;
}
inline void Command::set_has_set_operation_result_gpo() {
  _has_bits_[0] |= 0x00000800u;
}
inline void Command::clear_has_set_operation_result_gpo() {
  _has_bits_[0] &= ~0x00000800u;
}
inline void Command::clear_set_operation_result_gpo() {
  if (set_operation_result_gpo_ != NULL) set_operation_result_gpo_->::Impinj::STP::SetOperationResultGPOCommand::Clear();
  clear_has_set_operation_result_gpo();
}
inline const ::Impinj::STP::SetOperationResultGPOCommand& Command::set_operation_result_gpo() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return set_operation_result_gpo_ != NULL ? *set_operation_result_gpo_ : *default_instance().set_operation_result_gpo_;
#else
  return set_operation_result_gpo_ != NULL ? *set_operation_result_gpo_ : *default_instance_->set_operation_result_gpo_;
#endif
}
inline ::Impinj::STP::SetOperationResultGPOCommand* Command::mutable_set_operation_result_gpo() {
  set_has_set_operation_result_gpo();
  if (set_operation_result_gpo_ == NULL) set_operation_result_gpo_ = new ::Impinj::STP::SetOperationResultGPOCommand;
  return set_operation_result_gpo_;
}
inline ::Impinj::STP::SetOperationResultGPOCommand* Command::release_set_operation_result_gpo() {
  clear_has_set_operation_result_gpo();
  ::Impinj::STP::SetOperationResultGPOCommand* temp = set_operation_result_gpo_;
  set_operation_result_gpo_ = NULL;
  return temp;
}
inline void Command::set_allocated_set_operation_result_gpo(::Impinj::STP::SetOperationResultGPOCommand* set_operation_result_gpo) {
  delete set_operation_result_gpo_;
  set_operation_result_gpo_ = set_operation_result_gpo;
  if (set_operation_result_gpo) {
    set_has_set_operation_result_gpo();
  } else {
    clear_has_set_operation_result_gpo();
  }
}

// optional .Impinj.STP.AddSerializationJobCommand add_serialization_job = 12039;
inline bool Command::has_add_serialization_job() const {
  return (_has_bits_[0] & 0x00001000u) != 0;
}
inline void Command::set_has_add_serialization_job() {
  _has_bits_[0] |= 0x00001000u;
}
inline void Command::clear_has_add_serialization_job() {
  _has_bits_[0] &= ~0x00001000u;
}
inline void Command::clear_add_serialization_job() {
  if (add_serialization_job_ != NULL) add_serialization_job_->::Impinj::STP::AddSerializationJobCommand::Clear();
  clear_has_add_serialization_job();
}
inline const ::Impinj::STP::AddSerializationJobCommand& Command::add_serialization_job() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return add_serialization_job_ != NULL ? *add_serialization_job_ : *default_instance().add_serialization_job_;
#else
  return add_serialization_job_ != NULL ? *add_serialization_job_ : *default_instance_->add_serialization_job_;
#endif
}
inline ::Impinj::STP::AddSerializationJobCommand* Command::mutable_add_serialization_job() {
  set_has_add_serialization_job();
  if (add_serialization_job_ == NULL) add_serialization_job_ = new ::Impinj::STP::AddSerializationJobCommand;
  return add_serialization_job_;
}
inline ::Impinj::STP::AddSerializationJobCommand* Command::release_add_serialization_job() {
  clear_has_add_serialization_job();
  ::Impinj::STP::AddSerializationJobCommand* temp = add_serialization_job_;
  add_serialization_job_ = NULL;
  return temp;
}
inline void Command::set_allocated_add_serialization_job(::Impinj::STP::AddSerializationJobCommand* add_serialization_job) {
  delete add_serialization_job_;
  add_serialization_job_ = add_serialization_job;
  if (add_serialization_job) {
    set_has_add_serialization_job();
  } else {
    clear_has_add_serialization_job();
  }
}

// optional .Impinj.STP.RemoveSerializationJobCommand remove_serialization_job = 12040;
inline bool Command::has_remove_serialization_job() const {
  return (_has_bits_[0] & 0x00002000u) != 0;
}
inline void Command::set_has_remove_serialization_job() {
  _has_bits_[0] |= 0x00002000u;
}
inline void Command::clear_has_remove_serialization_job() {
  _has_bits_[0] &= ~0x00002000u;
}
inline void Command::clear_remove_serialization_job() {
  if (remove_serialization_job_ != NULL) remove_serialization_job_->::Impinj::STP::RemoveSerializationJobCommand::Clear();
  clear_has_remove_serialization_job();
}
inline const ::Impinj::STP::RemoveSerializationJobCommand& Command::remove_serialization_job() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return remove_serialization_job_ != NULL ? *remove_serialization_job_ : *default_instance().remove_serialization_job_;
#else
  return remove_serialization_job_ != NULL ? *remove_serialization_job_ : *default_instance_->remove_serialization_job_;
#endif
}
inline ::Impinj::STP::RemoveSerializationJobCommand* Command::mutable_remove_serialization_job() {
  set_has_remove_serialization_job();
  if (remove_serialization_job_ == NULL) remove_serialization_job_ = new ::Impinj::STP::RemoveSerializationJobCommand;
  return remove_serialization_job_;
}
inline ::Impinj::STP::RemoveSerializationJobCommand* Command::release_remove_serialization_job() {
  clear_has_remove_serialization_job();
  ::Impinj::STP::RemoveSerializationJobCommand* temp = remove_serialization_job_;
  remove_serialization_job_ = NULL;
  return temp;
}
inline void Command::set_allocated_remove_serialization_job(::Impinj::STP::RemoveSerializationJobCommand* remove_serialization_job) {
  delete remove_serialization_job_;
  remove_serialization_job_ = remove_serialization_job;
  if (remove_serialization_job) {
    set_has_remove_serialization_job();
  } else {
    clear_has_remove_serialization_job();
  }
}

// optional .Impinj.STP.AddTIDTableEntriesCommand add_tid_table_entries = 12041;
inline bool Command::has_add_tid_table_entries() const {
  return (_has_bits_[0] & 0x00004000u) != 0;
}
inline void Command::set_has_add_tid_table_entries() {
  _has_bits_[0] |= 0x00004000u;
}
inline void Command::clear_has_add_tid_table_entries() {
  _has_bits_[0] &= ~0x00004000u;
}
inline void Command::clear_add_tid_table_entries() {
  if (add_tid_table_entries_ != NULL) add_tid_table_entries_->::Impinj::STP::AddTIDTableEntriesCommand::Clear();
  clear_has_add_tid_table_entries();
}
inline const ::Impinj::STP::AddTIDTableEntriesCommand& Command::add_tid_table_entries() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return add_tid_table_entries_ != NULL ? *add_tid_table_entries_ : *default_instance().add_tid_table_entries_;
#else
  return add_tid_table_entries_ != NULL ? *add_tid_table_entries_ : *default_instance_->add_tid_table_entries_;
#endif
}
inline ::Impinj::STP::AddTIDTableEntriesCommand* Command::mutable_add_tid_table_entries() {
  set_has_add_tid_table_entries();
  if (add_tid_table_entries_ == NULL) add_tid_table_entries_ = new ::Impinj::STP::AddTIDTableEntriesCommand;
  return add_tid_table_entries_;
}
inline ::Impinj::STP::AddTIDTableEntriesCommand* Command::release_add_tid_table_entries() {
  clear_has_add_tid_table_entries();
  ::Impinj::STP::AddTIDTableEntriesCommand* temp = add_tid_table_entries_;
  add_tid_table_entries_ = NULL;
  return temp;
}
inline void Command::set_allocated_add_tid_table_entries(::Impinj::STP::AddTIDTableEntriesCommand* add_tid_table_entries) {
  delete add_tid_table_entries_;
  add_tid_table_entries_ = add_tid_table_entries;
  if (add_tid_table_entries) {
    set_has_add_tid_table_entries();
  } else {
    clear_has_add_tid_table_entries();
  }
}

// optional .Impinj.STP.AddOrderedListEntriesCommand add_ordered_list_entries = 12042;
inline bool Command::has_add_ordered_list_entries() const {
  return (_has_bits_[0] & 0x00008000u) != 0;
}
inline void Command::set_has_add_ordered_list_entries() {
  _has_bits_[0] |= 0x00008000u;
}
inline void Command::clear_has_add_ordered_list_entries() {
  _has_bits_[0] &= ~0x00008000u;
}
inline void Command::clear_add_ordered_list_entries() {
  if (add_ordered_list_entries_ != NULL) add_ordered_list_entries_->::Impinj::STP::AddOrderedListEntriesCommand::Clear();
  clear_has_add_ordered_list_entries();
}
inline const ::Impinj::STP::AddOrderedListEntriesCommand& Command::add_ordered_list_entries() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return add_ordered_list_entries_ != NULL ? *add_ordered_list_entries_ : *default_instance().add_ordered_list_entries_;
#else
  return add_ordered_list_entries_ != NULL ? *add_ordered_list_entries_ : *default_instance_->add_ordered_list_entries_;
#endif
}
inline ::Impinj::STP::AddOrderedListEntriesCommand* Command::mutable_add_ordered_list_entries() {
  set_has_add_ordered_list_entries();
  if (add_ordered_list_entries_ == NULL) add_ordered_list_entries_ = new ::Impinj::STP::AddOrderedListEntriesCommand;
  return add_ordered_list_entries_;
}
inline ::Impinj::STP::AddOrderedListEntriesCommand* Command::release_add_ordered_list_entries() {
  clear_has_add_ordered_list_entries();
  ::Impinj::STP::AddOrderedListEntriesCommand* temp = add_ordered_list_entries_;
  add_ordered_list_entries_ = NULL;
  return temp;
}
inline void Command::set_allocated_add_ordered_list_entries(::Impinj::STP::AddOrderedListEntriesCommand* add_ordered_list_entries) {
  delete add_ordered_list_entries_;
  add_ordered_list_entries_ = add_ordered_list_entries;
  if (add_ordered_list_entries) {
    set_has_add_ordered_list_entries();
  } else {
    clear_has_add_ordered_list_entries();
  }
}

// optional .Impinj.STP.SetInventoryJobCommand set_inventory_job = 12043;
inline bool Command::has_set_inventory_job() const {
  return (_has_bits_[0] & 0x00010000u) != 0;
}
inline void Command::set_has_set_inventory_job() {
  _has_bits_[0] |= 0x00010000u;
}
inline void Command::clear_has_set_inventory_job() {
  _has_bits_[0] &= ~0x00010000u;
}
inline void Command::clear_set_inventory_job() {
  if (set_inventory_job_ != NULL) set_inventory_job_->::Impinj::STP::SetInventoryJobCommand::Clear();
  clear_has_set_inventory_job();
}
inline const ::Impinj::STP::SetInventoryJobCommand& Command::set_inventory_job() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return set_inventory_job_ != NULL ? *set_inventory_job_ : *default_instance().set_inventory_job_;
#else
  return set_inventory_job_ != NULL ? *set_inventory_job_ : *default_instance_->set_inventory_job_;
#endif
}
inline ::Impinj::STP::SetInventoryJobCommand* Command::mutable_set_inventory_job() {
  set_has_set_inventory_job();
  if (set_inventory_job_ == NULL) set_inventory_job_ = new ::Impinj::STP::SetInventoryJobCommand;
  return set_inventory_job_;
}
inline ::Impinj::STP::SetInventoryJobCommand* Command::release_set_inventory_job() {
  clear_has_set_inventory_job();
  ::Impinj::STP::SetInventoryJobCommand* temp = set_inventory_job_;
  set_inventory_job_ = NULL;
  return temp;
}
inline void Command::set_allocated_set_inventory_job(::Impinj::STP::SetInventoryJobCommand* set_inventory_job) {
  delete set_inventory_job_;
  set_inventory_job_ = set_inventory_job;
  if (set_inventory_job) {
    set_has_set_inventory_job();
  } else {
    clear_has_set_inventory_job();
  }
}

// optional .Impinj.STP.SetCartonContentsJobCommand set_carton_contents_job = 12044;
inline bool Command::has_set_carton_contents_job() const {
  return (_has_bits_[0] & 0x00020000u) != 0;
}
inline void Command::set_has_set_carton_contents_job() {
  _has_bits_[0] |= 0x00020000u;
}
inline void Command::clear_has_set_carton_contents_job() {
  _has_bits_[0] &= ~0x00020000u;
}
inline void Command::clear_set_carton_contents_job() {
  if (set_carton_contents_job_ != NULL) set_carton_contents_job_->::Impinj::STP::SetCartonContentsJobCommand::Clear();
  clear_has_set_carton_contents_job();
}
inline const ::Impinj::STP::SetCartonContentsJobCommand& Command::set_carton_contents_job() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return set_carton_contents_job_ != NULL ? *set_carton_contents_job_ : *default_instance().set_carton_contents_job_;
#else
  return set_carton_contents_job_ != NULL ? *set_carton_contents_job_ : *default_instance_->set_carton_contents_job_;
#endif
}
inline ::Impinj::STP::SetCartonContentsJobCommand* Command::mutable_set_carton_contents_job() {
  set_has_set_carton_contents_job();
  if (set_carton_contents_job_ == NULL) set_carton_contents_job_ = new ::Impinj::STP::SetCartonContentsJobCommand;
  return set_carton_contents_job_;
}
inline ::Impinj::STP::SetCartonContentsJobCommand* Command::release_set_carton_contents_job() {
  clear_has_set_carton_contents_job();
  ::Impinj::STP::SetCartonContentsJobCommand* temp = set_carton_contents_job_;
  set_carton_contents_job_ = NULL;
  return temp;
}
inline void Command::set_allocated_set_carton_contents_job(::Impinj::STP::SetCartonContentsJobCommand* set_carton_contents_job) {
  delete set_carton_contents_job_;
  set_carton_contents_job_ = set_carton_contents_job;
  if (set_carton_contents_job) {
    set_has_set_carton_contents_job();
  } else {
    clear_has_set_carton_contents_job();
  }
}

// optional .Impinj.STP.GetOperationDataCommand get_operation_data = 12045;
inline bool Command::has_get_operation_data() const {
  return (_has_bits_[0] & 0x00040000u) != 0;
}
inline void Command::set_has_get_operation_data() {
  _has_bits_[0] |= 0x00040000u;
}
inline void Command::clear_has_get_operation_data() {
  _has_bits_[0] &= ~0x00040000u;
}
inline void Command::clear_get_operation_data() {
  if (get_operation_data_ != NULL) get_operation_data_->::Impinj::STP::GetOperationDataCommand::Clear();
  clear_has_get_operation_data();
}
inline const ::Impinj::STP::GetOperationDataCommand& Command::get_operation_data() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return get_operation_data_ != NULL ? *get_operation_data_ : *default_instance().get_operation_data_;
#else
  return get_operation_data_ != NULL ? *get_operation_data_ : *default_instance_->get_operation_data_;
#endif
}
inline ::Impinj::STP::GetOperationDataCommand* Command::mutable_get_operation_data() {
  set_has_get_operation_data();
  if (get_operation_data_ == NULL) get_operation_data_ = new ::Impinj::STP::GetOperationDataCommand;
  return get_operation_data_;
}
inline ::Impinj::STP::GetOperationDataCommand* Command::release_get_operation_data() {
  clear_has_get_operation_data();
  ::Impinj::STP::GetOperationDataCommand* temp = get_operation_data_;
  get_operation_data_ = NULL;
  return temp;
}
inline void Command::set_allocated_get_operation_data(::Impinj::STP::GetOperationDataCommand* get_operation_data) {
  delete get_operation_data_;
  get_operation_data_ = get_operation_data;
  if (get_operation_data) {
    set_has_get_operation_data();
  } else {
    clear_has_get_operation_data();
  }
}

// optional .Impinj.STP.AddLicenseKeyCommand add_license_key = 12046;
inline bool Command::has_add_license_key() const {
  return (_has_bits_[0] & 0x00080000u) != 0;
}
inline void Command::set_has_add_license_key() {
  _has_bits_[0] |= 0x00080000u;
}
inline void Command::clear_has_add_license_key() {
  _has_bits_[0] &= ~0x00080000u;
}
inline void Command::clear_add_license_key() {
  if (add_license_key_ != NULL) add_license_key_->::Impinj::STP::AddLicenseKeyCommand::Clear();
  clear_has_add_license_key();
}
inline const ::Impinj::STP::AddLicenseKeyCommand& Command::add_license_key() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return add_license_key_ != NULL ? *add_license_key_ : *default_instance().add_license_key_;
#else
  return add_license_key_ != NULL ? *add_license_key_ : *default_instance_->add_license_key_;
#endif
}
inline ::Impinj::STP::AddLicenseKeyCommand* Command::mutable_add_license_key() {
  set_has_add_license_key();
  if (add_license_key_ == NULL) add_license_key_ = new ::Impinj::STP::AddLicenseKeyCommand;
  return add_license_key_;
}
inline ::Impinj::STP::AddLicenseKeyCommand* Command::release_add_license_key() {
  clear_has_add_license_key();
  ::Impinj::STP::AddLicenseKeyCommand* temp = add_license_key_;
  add_license_key_ = NULL;
  return temp;
}
inline void Command::set_allocated_add_license_key(::Impinj::STP::AddLicenseKeyCommand* add_license_key) {
  delete add_license_key_;
  add_license_key_ = add_license_key;
  if (add_license_key) {
    set_has_add_license_key();
  } else {
    clear_has_add_license_key();
  }
}

// -------------------------------------------------------------------

// Response

// optional .Impinj.STP.ConnectResp connect = 1;
inline bool Response::has_connect() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Response::set_has_connect() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Response::clear_has_connect() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Response::clear_connect() {
  if (connect_ != NULL) connect_->::Impinj::STP::ConnectResp::Clear();
  clear_has_connect();
}
inline const ::Impinj::STP::ConnectResp& Response::connect() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return connect_ != NULL ? *connect_ : *default_instance().connect_;
#else
  return connect_ != NULL ? *connect_ : *default_instance_->connect_;
#endif
}
inline ::Impinj::STP::ConnectResp* Response::mutable_connect() {
  set_has_connect();
  if (connect_ == NULL) connect_ = new ::Impinj::STP::ConnectResp;
  return connect_;
}
inline ::Impinj::STP::ConnectResp* Response::release_connect() {
  clear_has_connect();
  ::Impinj::STP::ConnectResp* temp = connect_;
  connect_ = NULL;
  return temp;
}
inline void Response::set_allocated_connect(::Impinj::STP::ConnectResp* connect) {
  delete connect_;
  connect_ = connect;
  if (connect) {
    set_has_connect();
  } else {
    clear_has_connect();
  }
}

// optional .Impinj.STP.GetVersionsReaderResp get_versions_reader = 2;
inline bool Response::has_get_versions_reader() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void Response::set_has_get_versions_reader() {
  _has_bits_[0] |= 0x00000002u;
}
inline void Response::clear_has_get_versions_reader() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void Response::clear_get_versions_reader() {
  if (get_versions_reader_ != NULL) get_versions_reader_->::Impinj::STP::GetVersionsReaderResp::Clear();
  clear_has_get_versions_reader();
}
inline const ::Impinj::STP::GetVersionsReaderResp& Response::get_versions_reader() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return get_versions_reader_ != NULL ? *get_versions_reader_ : *default_instance().get_versions_reader_;
#else
  return get_versions_reader_ != NULL ? *get_versions_reader_ : *default_instance_->get_versions_reader_;
#endif
}
inline ::Impinj::STP::GetVersionsReaderResp* Response::mutable_get_versions_reader() {
  set_has_get_versions_reader();
  if (get_versions_reader_ == NULL) get_versions_reader_ = new ::Impinj::STP::GetVersionsReaderResp;
  return get_versions_reader_;
}
inline ::Impinj::STP::GetVersionsReaderResp* Response::release_get_versions_reader() {
  clear_has_get_versions_reader();
  ::Impinj::STP::GetVersionsReaderResp* temp = get_versions_reader_;
  get_versions_reader_ = NULL;
  return temp;
}
inline void Response::set_allocated_get_versions_reader(::Impinj::STP::GetVersionsReaderResp* get_versions_reader) {
  delete get_versions_reader_;
  get_versions_reader_ = get_versions_reader;
  if (get_versions_reader) {
    set_has_get_versions_reader();
  } else {
    clear_has_get_versions_reader();
  }
}

// optional .Impinj.STP.StartResp start = 7;
inline bool Response::has_start() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void Response::set_has_start() {
  _has_bits_[0] |= 0x00000004u;
}
inline void Response::clear_has_start() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void Response::clear_start() {
  if (start_ != NULL) start_->::Impinj::STP::StartResp::Clear();
  clear_has_start();
}
inline const ::Impinj::STP::StartResp& Response::start() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return start_ != NULL ? *start_ : *default_instance().start_;
#else
  return start_ != NULL ? *start_ : *default_instance_->start_;
#endif
}
inline ::Impinj::STP::StartResp* Response::mutable_start() {
  set_has_start();
  if (start_ == NULL) start_ = new ::Impinj::STP::StartResp;
  return start_;
}
inline ::Impinj::STP::StartResp* Response::release_start() {
  clear_has_start();
  ::Impinj::STP::StartResp* temp = start_;
  start_ = NULL;
  return temp;
}
inline void Response::set_allocated_start(::Impinj::STP::StartResp* start) {
  delete start_;
  start_ = start;
  if (start) {
    set_has_start();
  } else {
    clear_has_start();
  }
}

// optional .Impinj.STP.StopResp stop = 8;
inline bool Response::has_stop() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void Response::set_has_stop() {
  _has_bits_[0] |= 0x00000008u;
}
inline void Response::clear_has_stop() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void Response::clear_stop() {
  if (stop_ != NULL) stop_->::Impinj::STP::StopResp::Clear();
  clear_has_stop();
}
inline const ::Impinj::STP::StopResp& Response::stop() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return stop_ != NULL ? *stop_ : *default_instance().stop_;
#else
  return stop_ != NULL ? *stop_ : *default_instance_->stop_;
#endif
}
inline ::Impinj::STP::StopResp* Response::mutable_stop() {
  set_has_stop();
  if (stop_ == NULL) stop_ = new ::Impinj::STP::StopResp;
  return stop_;
}
inline ::Impinj::STP::StopResp* Response::release_stop() {
  clear_has_stop();
  ::Impinj::STP::StopResp* temp = stop_;
  stop_ = NULL;
  return temp;
}
inline void Response::set_allocated_stop(::Impinj::STP::StopResp* stop) {
  delete stop_;
  stop_ = stop;
  if (stop) {
    set_has_stop();
  } else {
    clear_has_stop();
  }
}

// optional .Impinj.STP.InvalidResp invalid = 15;
inline bool Response::has_invalid() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void Response::set_has_invalid() {
  _has_bits_[0] |= 0x00000010u;
}
inline void Response::clear_has_invalid() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void Response::clear_invalid() {
  if (invalid_ != NULL) invalid_->::Impinj::STP::InvalidResp::Clear();
  clear_has_invalid();
}
inline const ::Impinj::STP::InvalidResp& Response::invalid() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return invalid_ != NULL ? *invalid_ : *default_instance().invalid_;
#else
  return invalid_ != NULL ? *invalid_ : *default_instance_->invalid_;
#endif
}
inline ::Impinj::STP::InvalidResp* Response::mutable_invalid() {
  set_has_invalid();
  if (invalid_ == NULL) invalid_ = new ::Impinj::STP::InvalidResp;
  return invalid_;
}
inline ::Impinj::STP::InvalidResp* Response::release_invalid() {
  clear_has_invalid();
  ::Impinj::STP::InvalidResp* temp = invalid_;
  invalid_ = NULL;
  return temp;
}
inline void Response::set_allocated_invalid(::Impinj::STP::InvalidResp* invalid) {
  delete invalid_;
  invalid_ = invalid;
  if (invalid) {
    set_has_invalid();
  } else {
    clear_has_invalid();
  }
}

// optional .Impinj.STP.GetDeviceStateResp get_device_state = 25;
inline bool Response::has_get_device_state() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void Response::set_has_get_device_state() {
  _has_bits_[0] |= 0x00000020u;
}
inline void Response::clear_has_get_device_state() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void Response::clear_get_device_state() {
  if (get_device_state_ != NULL) get_device_state_->::Impinj::STP::GetDeviceStateResp::Clear();
  clear_has_get_device_state();
}
inline const ::Impinj::STP::GetDeviceStateResp& Response::get_device_state() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return get_device_state_ != NULL ? *get_device_state_ : *default_instance().get_device_state_;
#else
  return get_device_state_ != NULL ? *get_device_state_ : *default_instance_->get_device_state_;
#endif
}
inline ::Impinj::STP::GetDeviceStateResp* Response::mutable_get_device_state() {
  set_has_get_device_state();
  if (get_device_state_ == NULL) get_device_state_ = new ::Impinj::STP::GetDeviceStateResp;
  return get_device_state_;
}
inline ::Impinj::STP::GetDeviceStateResp* Response::release_get_device_state() {
  clear_has_get_device_state();
  ::Impinj::STP::GetDeviceStateResp* temp = get_device_state_;
  get_device_state_ = NULL;
  return temp;
}
inline void Response::set_allocated_get_device_state(::Impinj::STP::GetDeviceStateResp* get_device_state) {
  delete get_device_state_;
  get_device_state_ = get_device_state;
  if (get_device_state) {
    set_has_get_device_state();
  } else {
    clear_has_get_device_state();
  }
}

// optional .Impinj.STP.SetDeviceConfigResp set_device_config = 12032;
inline bool Response::has_set_device_config() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void Response::set_has_set_device_config() {
  _has_bits_[0] |= 0x00000040u;
}
inline void Response::clear_has_set_device_config() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void Response::clear_set_device_config() {
  if (set_device_config_ != NULL) set_device_config_->::Impinj::STP::SetDeviceConfigResp::Clear();
  clear_has_set_device_config();
}
inline const ::Impinj::STP::SetDeviceConfigResp& Response::set_device_config() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return set_device_config_ != NULL ? *set_device_config_ : *default_instance().set_device_config_;
#else
  return set_device_config_ != NULL ? *set_device_config_ : *default_instance_->set_device_config_;
#endif
}
inline ::Impinj::STP::SetDeviceConfigResp* Response::mutable_set_device_config() {
  set_has_set_device_config();
  if (set_device_config_ == NULL) set_device_config_ = new ::Impinj::STP::SetDeviceConfigResp;
  return set_device_config_;
}
inline ::Impinj::STP::SetDeviceConfigResp* Response::release_set_device_config() {
  clear_has_set_device_config();
  ::Impinj::STP::SetDeviceConfigResp* temp = set_device_config_;
  set_device_config_ = NULL;
  return temp;
}
inline void Response::set_allocated_set_device_config(::Impinj::STP::SetDeviceConfigResp* set_device_config) {
  delete set_device_config_;
  set_device_config_ = set_device_config;
  if (set_device_config) {
    set_has_set_device_config();
  } else {
    clear_has_set_device_config();
  }
}

// optional .Impinj.STP.GetDeviceConfigResp get_device_config = 12033;
inline bool Response::has_get_device_config() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void Response::set_has_get_device_config() {
  _has_bits_[0] |= 0x00000080u;
}
inline void Response::clear_has_get_device_config() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void Response::clear_get_device_config() {
  if (get_device_config_ != NULL) get_device_config_->::Impinj::STP::GetDeviceConfigResp::Clear();
  clear_has_get_device_config();
}
inline const ::Impinj::STP::GetDeviceConfigResp& Response::get_device_config() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return get_device_config_ != NULL ? *get_device_config_ : *default_instance().get_device_config_;
#else
  return get_device_config_ != NULL ? *get_device_config_ : *default_instance_->get_device_config_;
#endif
}
inline ::Impinj::STP::GetDeviceConfigResp* Response::mutable_get_device_config() {
  set_has_get_device_config();
  if (get_device_config_ == NULL) get_device_config_ = new ::Impinj::STP::GetDeviceConfigResp;
  return get_device_config_;
}
inline ::Impinj::STP::GetDeviceConfigResp* Response::release_get_device_config() {
  clear_has_get_device_config();
  ::Impinj::STP::GetDeviceConfigResp* temp = get_device_config_;
  get_device_config_ = NULL;
  return temp;
}
inline void Response::set_allocated_get_device_config(::Impinj::STP::GetDeviceConfigResp* get_device_config) {
  delete get_device_config_;
  get_device_config_ = get_device_config;
  if (get_device_config) {
    set_has_get_device_config();
  } else {
    clear_has_get_device_config();
  }
}

// optional .Impinj.STP.SetAntennaConfigResp set_antenna_config = 12034;
inline bool Response::has_set_antenna_config() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void Response::set_has_set_antenna_config() {
  _has_bits_[0] |= 0x00000100u;
}
inline void Response::clear_has_set_antenna_config() {
  _has_bits_[0] &= ~0x00000100u;
}
inline void Response::clear_set_antenna_config() {
  if (set_antenna_config_ != NULL) set_antenna_config_->::Impinj::STP::SetAntennaConfigResp::Clear();
  clear_has_set_antenna_config();
}
inline const ::Impinj::STP::SetAntennaConfigResp& Response::set_antenna_config() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return set_antenna_config_ != NULL ? *set_antenna_config_ : *default_instance().set_antenna_config_;
#else
  return set_antenna_config_ != NULL ? *set_antenna_config_ : *default_instance_->set_antenna_config_;
#endif
}
inline ::Impinj::STP::SetAntennaConfigResp* Response::mutable_set_antenna_config() {
  set_has_set_antenna_config();
  if (set_antenna_config_ == NULL) set_antenna_config_ = new ::Impinj::STP::SetAntennaConfigResp;
  return set_antenna_config_;
}
inline ::Impinj::STP::SetAntennaConfigResp* Response::release_set_antenna_config() {
  clear_has_set_antenna_config();
  ::Impinj::STP::SetAntennaConfigResp* temp = set_antenna_config_;
  set_antenna_config_ = NULL;
  return temp;
}
inline void Response::set_allocated_set_antenna_config(::Impinj::STP::SetAntennaConfigResp* set_antenna_config) {
  delete set_antenna_config_;
  set_antenna_config_ = set_antenna_config;
  if (set_antenna_config) {
    set_has_set_antenna_config();
  } else {
    clear_has_set_antenna_config();
  }
}

// optional .Impinj.STP.GetAntennaConfigResp get_antenna_config = 12035;
inline bool Response::has_get_antenna_config() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void Response::set_has_get_antenna_config() {
  _has_bits_[0] |= 0x00000200u;
}
inline void Response::clear_has_get_antenna_config() {
  _has_bits_[0] &= ~0x00000200u;
}
inline void Response::clear_get_antenna_config() {
  if (get_antenna_config_ != NULL) get_antenna_config_->::Impinj::STP::GetAntennaConfigResp::Clear();
  clear_has_get_antenna_config();
}
inline const ::Impinj::STP::GetAntennaConfigResp& Response::get_antenna_config() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return get_antenna_config_ != NULL ? *get_antenna_config_ : *default_instance().get_antenna_config_;
#else
  return get_antenna_config_ != NULL ? *get_antenna_config_ : *default_instance_->get_antenna_config_;
#endif
}
inline ::Impinj::STP::GetAntennaConfigResp* Response::mutable_get_antenna_config() {
  set_has_get_antenna_config();
  if (get_antenna_config_ == NULL) get_antenna_config_ = new ::Impinj::STP::GetAntennaConfigResp;
  return get_antenna_config_;
}
inline ::Impinj::STP::GetAntennaConfigResp* Response::release_get_antenna_config() {
  clear_has_get_antenna_config();
  ::Impinj::STP::GetAntennaConfigResp* temp = get_antenna_config_;
  get_antenna_config_ = NULL;
  return temp;
}
inline void Response::set_allocated_get_antenna_config(::Impinj::STP::GetAntennaConfigResp* get_antenna_config) {
  delete get_antenna_config_;
  get_antenna_config_ = get_antenna_config;
  if (get_antenna_config) {
    set_has_get_antenna_config();
  } else {
    clear_has_get_antenna_config();
  }
}

// optional .Impinj.STP.EngageResp engage = 12036;
inline bool Response::has_engage() const {
  return (_has_bits_[0] & 0x00000400u) != 0;
}
inline void Response::set_has_engage() {
  _has_bits_[0] |= 0x00000400u;
}
inline void Response::clear_has_engage() {
  _has_bits_[0] &= ~0x00000400u;
}
inline void Response::clear_engage() {
  if (engage_ != NULL) engage_->::Impinj::STP::EngageResp::Clear();
  clear_has_engage();
}
inline const ::Impinj::STP::EngageResp& Response::engage() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return engage_ != NULL ? *engage_ : *default_instance().engage_;
#else
  return engage_ != NULL ? *engage_ : *default_instance_->engage_;
#endif
}
inline ::Impinj::STP::EngageResp* Response::mutable_engage() {
  set_has_engage();
  if (engage_ == NULL) engage_ = new ::Impinj::STP::EngageResp;
  return engage_;
}
inline ::Impinj::STP::EngageResp* Response::release_engage() {
  clear_has_engage();
  ::Impinj::STP::EngageResp* temp = engage_;
  engage_ = NULL;
  return temp;
}
inline void Response::set_allocated_engage(::Impinj::STP::EngageResp* engage) {
  delete engage_;
  engage_ = engage;
  if (engage) {
    set_has_engage();
  } else {
    clear_has_engage();
  }
}

// optional .Impinj.STP.DisengageResp disengage = 12037;
inline bool Response::has_disengage() const {
  return (_has_bits_[0] & 0x00000800u) != 0;
}
inline void Response::set_has_disengage() {
  _has_bits_[0] |= 0x00000800u;
}
inline void Response::clear_has_disengage() {
  _has_bits_[0] &= ~0x00000800u;
}
inline void Response::clear_disengage() {
  if (disengage_ != NULL) disengage_->::Impinj::STP::DisengageResp::Clear();
  clear_has_disengage();
}
inline const ::Impinj::STP::DisengageResp& Response::disengage() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return disengage_ != NULL ? *disengage_ : *default_instance().disengage_;
#else
  return disengage_ != NULL ? *disengage_ : *default_instance_->disengage_;
#endif
}
inline ::Impinj::STP::DisengageResp* Response::mutable_disengage() {
  set_has_disengage();
  if (disengage_ == NULL) disengage_ = new ::Impinj::STP::DisengageResp;
  return disengage_;
}
inline ::Impinj::STP::DisengageResp* Response::release_disengage() {
  clear_has_disengage();
  ::Impinj::STP::DisengageResp* temp = disengage_;
  disengage_ = NULL;
  return temp;
}
inline void Response::set_allocated_disengage(::Impinj::STP::DisengageResp* disengage) {
  delete disengage_;
  disengage_ = disengage;
  if (disengage) {
    set_has_disengage();
  } else {
    clear_has_disengage();
  }
}

// optional .Impinj.STP.SetOperationResultGPOResp set_operation_result_gpo = 12041;
inline bool Response::has_set_operation_result_gpo() const {
  return (_has_bits_[0] & 0x00001000u) != 0;
}
inline void Response::set_has_set_operation_result_gpo() {
  _has_bits_[0] |= 0x00001000u;
}
inline void Response::clear_has_set_operation_result_gpo() {
  _has_bits_[0] &= ~0x00001000u;
}
inline void Response::clear_set_operation_result_gpo() {
  if (set_operation_result_gpo_ != NULL) set_operation_result_gpo_->::Impinj::STP::SetOperationResultGPOResp::Clear();
  clear_has_set_operation_result_gpo();
}
inline const ::Impinj::STP::SetOperationResultGPOResp& Response::set_operation_result_gpo() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return set_operation_result_gpo_ != NULL ? *set_operation_result_gpo_ : *default_instance().set_operation_result_gpo_;
#else
  return set_operation_result_gpo_ != NULL ? *set_operation_result_gpo_ : *default_instance_->set_operation_result_gpo_;
#endif
}
inline ::Impinj::STP::SetOperationResultGPOResp* Response::mutable_set_operation_result_gpo() {
  set_has_set_operation_result_gpo();
  if (set_operation_result_gpo_ == NULL) set_operation_result_gpo_ = new ::Impinj::STP::SetOperationResultGPOResp;
  return set_operation_result_gpo_;
}
inline ::Impinj::STP::SetOperationResultGPOResp* Response::release_set_operation_result_gpo() {
  clear_has_set_operation_result_gpo();
  ::Impinj::STP::SetOperationResultGPOResp* temp = set_operation_result_gpo_;
  set_operation_result_gpo_ = NULL;
  return temp;
}
inline void Response::set_allocated_set_operation_result_gpo(::Impinj::STP::SetOperationResultGPOResp* set_operation_result_gpo) {
  delete set_operation_result_gpo_;
  set_operation_result_gpo_ = set_operation_result_gpo;
  if (set_operation_result_gpo) {
    set_has_set_operation_result_gpo();
  } else {
    clear_has_set_operation_result_gpo();
  }
}

// optional .Impinj.STP.AddSerializationJobResp add_serialization_job = 12042;
inline bool Response::has_add_serialization_job() const {
  return (_has_bits_[0] & 0x00002000u) != 0;
}
inline void Response::set_has_add_serialization_job() {
  _has_bits_[0] |= 0x00002000u;
}
inline void Response::clear_has_add_serialization_job() {
  _has_bits_[0] &= ~0x00002000u;
}
inline void Response::clear_add_serialization_job() {
  if (add_serialization_job_ != NULL) add_serialization_job_->::Impinj::STP::AddSerializationJobResp::Clear();
  clear_has_add_serialization_job();
}
inline const ::Impinj::STP::AddSerializationJobResp& Response::add_serialization_job() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return add_serialization_job_ != NULL ? *add_serialization_job_ : *default_instance().add_serialization_job_;
#else
  return add_serialization_job_ != NULL ? *add_serialization_job_ : *default_instance_->add_serialization_job_;
#endif
}
inline ::Impinj::STP::AddSerializationJobResp* Response::mutable_add_serialization_job() {
  set_has_add_serialization_job();
  if (add_serialization_job_ == NULL) add_serialization_job_ = new ::Impinj::STP::AddSerializationJobResp;
  return add_serialization_job_;
}
inline ::Impinj::STP::AddSerializationJobResp* Response::release_add_serialization_job() {
  clear_has_add_serialization_job();
  ::Impinj::STP::AddSerializationJobResp* temp = add_serialization_job_;
  add_serialization_job_ = NULL;
  return temp;
}
inline void Response::set_allocated_add_serialization_job(::Impinj::STP::AddSerializationJobResp* add_serialization_job) {
  delete add_serialization_job_;
  add_serialization_job_ = add_serialization_job;
  if (add_serialization_job) {
    set_has_add_serialization_job();
  } else {
    clear_has_add_serialization_job();
  }
}

// optional .Impinj.STP.RemoveSerializationJobResp remove_serialization_job = 12043;
inline bool Response::has_remove_serialization_job() const {
  return (_has_bits_[0] & 0x00004000u) != 0;
}
inline void Response::set_has_remove_serialization_job() {
  _has_bits_[0] |= 0x00004000u;
}
inline void Response::clear_has_remove_serialization_job() {
  _has_bits_[0] &= ~0x00004000u;
}
inline void Response::clear_remove_serialization_job() {
  if (remove_serialization_job_ != NULL) remove_serialization_job_->::Impinj::STP::RemoveSerializationJobResp::Clear();
  clear_has_remove_serialization_job();
}
inline const ::Impinj::STP::RemoveSerializationJobResp& Response::remove_serialization_job() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return remove_serialization_job_ != NULL ? *remove_serialization_job_ : *default_instance().remove_serialization_job_;
#else
  return remove_serialization_job_ != NULL ? *remove_serialization_job_ : *default_instance_->remove_serialization_job_;
#endif
}
inline ::Impinj::STP::RemoveSerializationJobResp* Response::mutable_remove_serialization_job() {
  set_has_remove_serialization_job();
  if (remove_serialization_job_ == NULL) remove_serialization_job_ = new ::Impinj::STP::RemoveSerializationJobResp;
  return remove_serialization_job_;
}
inline ::Impinj::STP::RemoveSerializationJobResp* Response::release_remove_serialization_job() {
  clear_has_remove_serialization_job();
  ::Impinj::STP::RemoveSerializationJobResp* temp = remove_serialization_job_;
  remove_serialization_job_ = NULL;
  return temp;
}
inline void Response::set_allocated_remove_serialization_job(::Impinj::STP::RemoveSerializationJobResp* remove_serialization_job) {
  delete remove_serialization_job_;
  remove_serialization_job_ = remove_serialization_job;
  if (remove_serialization_job) {
    set_has_remove_serialization_job();
  } else {
    clear_has_remove_serialization_job();
  }
}

// optional .Impinj.STP.AddTIDTableEntriesResp add_tid_table_entries = 12044;
inline bool Response::has_add_tid_table_entries() const {
  return (_has_bits_[0] & 0x00008000u) != 0;
}
inline void Response::set_has_add_tid_table_entries() {
  _has_bits_[0] |= 0x00008000u;
}
inline void Response::clear_has_add_tid_table_entries() {
  _has_bits_[0] &= ~0x00008000u;
}
inline void Response::clear_add_tid_table_entries() {
  if (add_tid_table_entries_ != NULL) add_tid_table_entries_->::Impinj::STP::AddTIDTableEntriesResp::Clear();
  clear_has_add_tid_table_entries();
}
inline const ::Impinj::STP::AddTIDTableEntriesResp& Response::add_tid_table_entries() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return add_tid_table_entries_ != NULL ? *add_tid_table_entries_ : *default_instance().add_tid_table_entries_;
#else
  return add_tid_table_entries_ != NULL ? *add_tid_table_entries_ : *default_instance_->add_tid_table_entries_;
#endif
}
inline ::Impinj::STP::AddTIDTableEntriesResp* Response::mutable_add_tid_table_entries() {
  set_has_add_tid_table_entries();
  if (add_tid_table_entries_ == NULL) add_tid_table_entries_ = new ::Impinj::STP::AddTIDTableEntriesResp;
  return add_tid_table_entries_;
}
inline ::Impinj::STP::AddTIDTableEntriesResp* Response::release_add_tid_table_entries() {
  clear_has_add_tid_table_entries();
  ::Impinj::STP::AddTIDTableEntriesResp* temp = add_tid_table_entries_;
  add_tid_table_entries_ = NULL;
  return temp;
}
inline void Response::set_allocated_add_tid_table_entries(::Impinj::STP::AddTIDTableEntriesResp* add_tid_table_entries) {
  delete add_tid_table_entries_;
  add_tid_table_entries_ = add_tid_table_entries;
  if (add_tid_table_entries) {
    set_has_add_tid_table_entries();
  } else {
    clear_has_add_tid_table_entries();
  }
}

// optional .Impinj.STP.AddOrderedListEntriesResp add_ordered_list_entries = 12045;
inline bool Response::has_add_ordered_list_entries() const {
  return (_has_bits_[0] & 0x00010000u) != 0;
}
inline void Response::set_has_add_ordered_list_entries() {
  _has_bits_[0] |= 0x00010000u;
}
inline void Response::clear_has_add_ordered_list_entries() {
  _has_bits_[0] &= ~0x00010000u;
}
inline void Response::clear_add_ordered_list_entries() {
  if (add_ordered_list_entries_ != NULL) add_ordered_list_entries_->::Impinj::STP::AddOrderedListEntriesResp::Clear();
  clear_has_add_ordered_list_entries();
}
inline const ::Impinj::STP::AddOrderedListEntriesResp& Response::add_ordered_list_entries() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return add_ordered_list_entries_ != NULL ? *add_ordered_list_entries_ : *default_instance().add_ordered_list_entries_;
#else
  return add_ordered_list_entries_ != NULL ? *add_ordered_list_entries_ : *default_instance_->add_ordered_list_entries_;
#endif
}
inline ::Impinj::STP::AddOrderedListEntriesResp* Response::mutable_add_ordered_list_entries() {
  set_has_add_ordered_list_entries();
  if (add_ordered_list_entries_ == NULL) add_ordered_list_entries_ = new ::Impinj::STP::AddOrderedListEntriesResp;
  return add_ordered_list_entries_;
}
inline ::Impinj::STP::AddOrderedListEntriesResp* Response::release_add_ordered_list_entries() {
  clear_has_add_ordered_list_entries();
  ::Impinj::STP::AddOrderedListEntriesResp* temp = add_ordered_list_entries_;
  add_ordered_list_entries_ = NULL;
  return temp;
}
inline void Response::set_allocated_add_ordered_list_entries(::Impinj::STP::AddOrderedListEntriesResp* add_ordered_list_entries) {
  delete add_ordered_list_entries_;
  add_ordered_list_entries_ = add_ordered_list_entries;
  if (add_ordered_list_entries) {
    set_has_add_ordered_list_entries();
  } else {
    clear_has_add_ordered_list_entries();
  }
}

// optional .Impinj.STP.SetInventoryJobResp set_inventory_job = 12046;
inline bool Response::has_set_inventory_job() const {
  return (_has_bits_[0] & 0x00020000u) != 0;
}
inline void Response::set_has_set_inventory_job() {
  _has_bits_[0] |= 0x00020000u;
}
inline void Response::clear_has_set_inventory_job() {
  _has_bits_[0] &= ~0x00020000u;
}
inline void Response::clear_set_inventory_job() {
  if (set_inventory_job_ != NULL) set_inventory_job_->::Impinj::STP::SetInventoryJobResp::Clear();
  clear_has_set_inventory_job();
}
inline const ::Impinj::STP::SetInventoryJobResp& Response::set_inventory_job() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return set_inventory_job_ != NULL ? *set_inventory_job_ : *default_instance().set_inventory_job_;
#else
  return set_inventory_job_ != NULL ? *set_inventory_job_ : *default_instance_->set_inventory_job_;
#endif
}
inline ::Impinj::STP::SetInventoryJobResp* Response::mutable_set_inventory_job() {
  set_has_set_inventory_job();
  if (set_inventory_job_ == NULL) set_inventory_job_ = new ::Impinj::STP::SetInventoryJobResp;
  return set_inventory_job_;
}
inline ::Impinj::STP::SetInventoryJobResp* Response::release_set_inventory_job() {
  clear_has_set_inventory_job();
  ::Impinj::STP::SetInventoryJobResp* temp = set_inventory_job_;
  set_inventory_job_ = NULL;
  return temp;
}
inline void Response::set_allocated_set_inventory_job(::Impinj::STP::SetInventoryJobResp* set_inventory_job) {
  delete set_inventory_job_;
  set_inventory_job_ = set_inventory_job;
  if (set_inventory_job) {
    set_has_set_inventory_job();
  } else {
    clear_has_set_inventory_job();
  }
}

// optional .Impinj.STP.SetCartonContentsJobResp set_carton_contents_job = 12047;
inline bool Response::has_set_carton_contents_job() const {
  return (_has_bits_[0] & 0x00040000u) != 0;
}
inline void Response::set_has_set_carton_contents_job() {
  _has_bits_[0] |= 0x00040000u;
}
inline void Response::clear_has_set_carton_contents_job() {
  _has_bits_[0] &= ~0x00040000u;
}
inline void Response::clear_set_carton_contents_job() {
  if (set_carton_contents_job_ != NULL) set_carton_contents_job_->::Impinj::STP::SetCartonContentsJobResp::Clear();
  clear_has_set_carton_contents_job();
}
inline const ::Impinj::STP::SetCartonContentsJobResp& Response::set_carton_contents_job() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return set_carton_contents_job_ != NULL ? *set_carton_contents_job_ : *default_instance().set_carton_contents_job_;
#else
  return set_carton_contents_job_ != NULL ? *set_carton_contents_job_ : *default_instance_->set_carton_contents_job_;
#endif
}
inline ::Impinj::STP::SetCartonContentsJobResp* Response::mutable_set_carton_contents_job() {
  set_has_set_carton_contents_job();
  if (set_carton_contents_job_ == NULL) set_carton_contents_job_ = new ::Impinj::STP::SetCartonContentsJobResp;
  return set_carton_contents_job_;
}
inline ::Impinj::STP::SetCartonContentsJobResp* Response::release_set_carton_contents_job() {
  clear_has_set_carton_contents_job();
  ::Impinj::STP::SetCartonContentsJobResp* temp = set_carton_contents_job_;
  set_carton_contents_job_ = NULL;
  return temp;
}
inline void Response::set_allocated_set_carton_contents_job(::Impinj::STP::SetCartonContentsJobResp* set_carton_contents_job) {
  delete set_carton_contents_job_;
  set_carton_contents_job_ = set_carton_contents_job;
  if (set_carton_contents_job) {
    set_has_set_carton_contents_job();
  } else {
    clear_has_set_carton_contents_job();
  }
}

// optional .Impinj.STP.GetOperationDataResp get_operation_data = 12048;
inline bool Response::has_get_operation_data() const {
  return (_has_bits_[0] & 0x00080000u) != 0;
}
inline void Response::set_has_get_operation_data() {
  _has_bits_[0] |= 0x00080000u;
}
inline void Response::clear_has_get_operation_data() {
  _has_bits_[0] &= ~0x00080000u;
}
inline void Response::clear_get_operation_data() {
  if (get_operation_data_ != NULL) get_operation_data_->::Impinj::STP::GetOperationDataResp::Clear();
  clear_has_get_operation_data();
}
inline const ::Impinj::STP::GetOperationDataResp& Response::get_operation_data() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return get_operation_data_ != NULL ? *get_operation_data_ : *default_instance().get_operation_data_;
#else
  return get_operation_data_ != NULL ? *get_operation_data_ : *default_instance_->get_operation_data_;
#endif
}
inline ::Impinj::STP::GetOperationDataResp* Response::mutable_get_operation_data() {
  set_has_get_operation_data();
  if (get_operation_data_ == NULL) get_operation_data_ = new ::Impinj::STP::GetOperationDataResp;
  return get_operation_data_;
}
inline ::Impinj::STP::GetOperationDataResp* Response::release_get_operation_data() {
  clear_has_get_operation_data();
  ::Impinj::STP::GetOperationDataResp* temp = get_operation_data_;
  get_operation_data_ = NULL;
  return temp;
}
inline void Response::set_allocated_get_operation_data(::Impinj::STP::GetOperationDataResp* get_operation_data) {
  delete get_operation_data_;
  get_operation_data_ = get_operation_data;
  if (get_operation_data) {
    set_has_get_operation_data();
  } else {
    clear_has_get_operation_data();
  }
}

// optional .Impinj.STP.AddLicenseKeyResp add_license_key = 12049;
inline bool Response::has_add_license_key() const {
  return (_has_bits_[0] & 0x00100000u) != 0;
}
inline void Response::set_has_add_license_key() {
  _has_bits_[0] |= 0x00100000u;
}
inline void Response::clear_has_add_license_key() {
  _has_bits_[0] &= ~0x00100000u;
}
inline void Response::clear_add_license_key() {
  if (add_license_key_ != NULL) add_license_key_->::Impinj::STP::AddLicenseKeyResp::Clear();
  clear_has_add_license_key();
}
inline const ::Impinj::STP::AddLicenseKeyResp& Response::add_license_key() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return add_license_key_ != NULL ? *add_license_key_ : *default_instance().add_license_key_;
#else
  return add_license_key_ != NULL ? *add_license_key_ : *default_instance_->add_license_key_;
#endif
}
inline ::Impinj::STP::AddLicenseKeyResp* Response::mutable_add_license_key() {
  set_has_add_license_key();
  if (add_license_key_ == NULL) add_license_key_ = new ::Impinj::STP::AddLicenseKeyResp;
  return add_license_key_;
}
inline ::Impinj::STP::AddLicenseKeyResp* Response::release_add_license_key() {
  clear_has_add_license_key();
  ::Impinj::STP::AddLicenseKeyResp* temp = add_license_key_;
  add_license_key_ = NULL;
  return temp;
}
inline void Response::set_allocated_add_license_key(::Impinj::STP::AddLicenseKeyResp* add_license_key) {
  delete add_license_key_;
  add_license_key_ = add_license_key;
  if (add_license_key) {
    set_has_add_license_key();
  } else {
    clear_has_add_license_key();
  }
}

// -------------------------------------------------------------------

// Report

// optional .Impinj.STP.DeviceEventReport device_event_report = 1;
inline bool Report::has_device_event_report() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Report::set_has_device_event_report() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Report::clear_has_device_event_report() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Report::clear_device_event_report() {
  if (device_event_report_ != NULL) device_event_report_->::Impinj::STP::DeviceEventReport::Clear();
  clear_has_device_event_report();
}
inline const ::Impinj::STP::DeviceEventReport& Report::device_event_report() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return device_event_report_ != NULL ? *device_event_report_ : *default_instance().device_event_report_;
#else
  return device_event_report_ != NULL ? *device_event_report_ : *default_instance_->device_event_report_;
#endif
}
inline ::Impinj::STP::DeviceEventReport* Report::mutable_device_event_report() {
  set_has_device_event_report();
  if (device_event_report_ == NULL) device_event_report_ = new ::Impinj::STP::DeviceEventReport;
  return device_event_report_;
}
inline ::Impinj::STP::DeviceEventReport* Report::release_device_event_report() {
  clear_has_device_event_report();
  ::Impinj::STP::DeviceEventReport* temp = device_event_report_;
  device_event_report_ = NULL;
  return temp;
}
inline void Report::set_allocated_device_event_report(::Impinj::STP::DeviceEventReport* device_event_report) {
  delete device_event_report_;
  device_event_report_ = device_event_report;
  if (device_event_report) {
    set_has_device_event_report();
  } else {
    clear_has_device_event_report();
  }
}

// optional .Impinj.STP.TagOperationReport tag_operation_report = 2;
inline bool Report::has_tag_operation_report() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void Report::set_has_tag_operation_report() {
  _has_bits_[0] |= 0x00000002u;
}
inline void Report::clear_has_tag_operation_report() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void Report::clear_tag_operation_report() {
  if (tag_operation_report_ != NULL) tag_operation_report_->::Impinj::STP::TagOperationReport::Clear();
  clear_has_tag_operation_report();
}
inline const ::Impinj::STP::TagOperationReport& Report::tag_operation_report() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return tag_operation_report_ != NULL ? *tag_operation_report_ : *default_instance().tag_operation_report_;
#else
  return tag_operation_report_ != NULL ? *tag_operation_report_ : *default_instance_->tag_operation_report_;
#endif
}
inline ::Impinj::STP::TagOperationReport* Report::mutable_tag_operation_report() {
  set_has_tag_operation_report();
  if (tag_operation_report_ == NULL) tag_operation_report_ = new ::Impinj::STP::TagOperationReport;
  return tag_operation_report_;
}
inline ::Impinj::STP::TagOperationReport* Report::release_tag_operation_report() {
  clear_has_tag_operation_report();
  ::Impinj::STP::TagOperationReport* temp = tag_operation_report_;
  tag_operation_report_ = NULL;
  return temp;
}
inline void Report::set_allocated_tag_operation_report(::Impinj::STP::TagOperationReport* tag_operation_report) {
  delete tag_operation_report_;
  tag_operation_report_ = tag_operation_report;
  if (tag_operation_report) {
    set_has_tag_operation_report();
  } else {
    clear_has_tag_operation_report();
  }
}

// optional .Impinj.STP.OperationSummaryReport operation_summary_report = 3;
inline bool Report::has_operation_summary_report() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void Report::set_has_operation_summary_report() {
  _has_bits_[0] |= 0x00000004u;
}
inline void Report::clear_has_operation_summary_report() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void Report::clear_operation_summary_report() {
  if (operation_summary_report_ != NULL) operation_summary_report_->::Impinj::STP::OperationSummaryReport::Clear();
  clear_has_operation_summary_report();
}
inline const ::Impinj::STP::OperationSummaryReport& Report::operation_summary_report() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return operation_summary_report_ != NULL ? *operation_summary_report_ : *default_instance().operation_summary_report_;
#else
  return operation_summary_report_ != NULL ? *operation_summary_report_ : *default_instance_->operation_summary_report_;
#endif
}
inline ::Impinj::STP::OperationSummaryReport* Report::mutable_operation_summary_report() {
  set_has_operation_summary_report();
  if (operation_summary_report_ == NULL) operation_summary_report_ = new ::Impinj::STP::OperationSummaryReport;
  return operation_summary_report_;
}
inline ::Impinj::STP::OperationSummaryReport* Report::release_operation_summary_report() {
  clear_has_operation_summary_report();
  ::Impinj::STP::OperationSummaryReport* temp = operation_summary_report_;
  operation_summary_report_ = NULL;
  return temp;
}
inline void Report::set_allocated_operation_summary_report(::Impinj::STP::OperationSummaryReport* operation_summary_report) {
  delete operation_summary_report_;
  operation_summary_report_ = operation_summary_report;
  if (operation_summary_report) {
    set_has_operation_summary_report();
  } else {
    clear_has_operation_summary_report();
  }
}

// optional .Impinj.STP.CartonContentsReport carton_contents_report = 4;
inline bool Report::has_carton_contents_report() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void Report::set_has_carton_contents_report() {
  _has_bits_[0] |= 0x00000008u;
}
inline void Report::clear_has_carton_contents_report() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void Report::clear_carton_contents_report() {
  if (carton_contents_report_ != NULL) carton_contents_report_->::Impinj::STP::CartonContentsReport::Clear();
  clear_has_carton_contents_report();
}
inline const ::Impinj::STP::CartonContentsReport& Report::carton_contents_report() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return carton_contents_report_ != NULL ? *carton_contents_report_ : *default_instance().carton_contents_report_;
#else
  return carton_contents_report_ != NULL ? *carton_contents_report_ : *default_instance_->carton_contents_report_;
#endif
}
inline ::Impinj::STP::CartonContentsReport* Report::mutable_carton_contents_report() {
  set_has_carton_contents_report();
  if (carton_contents_report_ == NULL) carton_contents_report_ = new ::Impinj::STP::CartonContentsReport;
  return carton_contents_report_;
}
inline ::Impinj::STP::CartonContentsReport* Report::release_carton_contents_report() {
  clear_has_carton_contents_report();
  ::Impinj::STP::CartonContentsReport* temp = carton_contents_report_;
  carton_contents_report_ = NULL;
  return temp;
}
inline void Report::set_allocated_carton_contents_report(::Impinj::STP::CartonContentsReport* carton_contents_report) {
  delete carton_contents_report_;
  carton_contents_report_ = carton_contents_report;
  if (carton_contents_report) {
    set_has_carton_contents_report();
  } else {
    clear_has_carton_contents_report();
  }
}

// -------------------------------------------------------------------

// Update

// optional .Impinj.STP.AddTIDTableEntriesCommand add_tid_table_entries = 1;
inline bool Update::has_add_tid_table_entries() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Update::set_has_add_tid_table_entries() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Update::clear_has_add_tid_table_entries() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Update::clear_add_tid_table_entries() {
  if (add_tid_table_entries_ != NULL) add_tid_table_entries_->::Impinj::STP::AddTIDTableEntriesCommand::Clear();
  clear_has_add_tid_table_entries();
}
inline const ::Impinj::STP::AddTIDTableEntriesCommand& Update::add_tid_table_entries() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return add_tid_table_entries_ != NULL ? *add_tid_table_entries_ : *default_instance().add_tid_table_entries_;
#else
  return add_tid_table_entries_ != NULL ? *add_tid_table_entries_ : *default_instance_->add_tid_table_entries_;
#endif
}
inline ::Impinj::STP::AddTIDTableEntriesCommand* Update::mutable_add_tid_table_entries() {
  set_has_add_tid_table_entries();
  if (add_tid_table_entries_ == NULL) add_tid_table_entries_ = new ::Impinj::STP::AddTIDTableEntriesCommand;
  return add_tid_table_entries_;
}
inline ::Impinj::STP::AddTIDTableEntriesCommand* Update::release_add_tid_table_entries() {
  clear_has_add_tid_table_entries();
  ::Impinj::STP::AddTIDTableEntriesCommand* temp = add_tid_table_entries_;
  add_tid_table_entries_ = NULL;
  return temp;
}
inline void Update::set_allocated_add_tid_table_entries(::Impinj::STP::AddTIDTableEntriesCommand* add_tid_table_entries) {
  delete add_tid_table_entries_;
  add_tid_table_entries_ = add_tid_table_entries;
  if (add_tid_table_entries) {
    set_has_add_tid_table_entries();
  } else {
    clear_has_add_tid_table_entries();
  }
}

// -------------------------------------------------------------------

// Packet

// optional .Impinj.STP.Command command = 3;
inline bool Packet::has_command() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Packet::set_has_command() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Packet::clear_has_command() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Packet::clear_command() {
  if (command_ != NULL) command_->::Impinj::STP::Command::Clear();
  clear_has_command();
}
inline const ::Impinj::STP::Command& Packet::command() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return command_ != NULL ? *command_ : *default_instance().command_;
#else
  return command_ != NULL ? *command_ : *default_instance_->command_;
#endif
}
inline ::Impinj::STP::Command* Packet::mutable_command() {
  set_has_command();
  if (command_ == NULL) command_ = new ::Impinj::STP::Command;
  return command_;
}
inline ::Impinj::STP::Command* Packet::release_command() {
  clear_has_command();
  ::Impinj::STP::Command* temp = command_;
  command_ = NULL;
  return temp;
}
inline void Packet::set_allocated_command(::Impinj::STP::Command* command) {
  delete command_;
  command_ = command;
  if (command) {
    set_has_command();
  } else {
    clear_has_command();
  }
}

// optional .Impinj.STP.Response response = 4;
inline bool Packet::has_response() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void Packet::set_has_response() {
  _has_bits_[0] |= 0x00000002u;
}
inline void Packet::clear_has_response() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void Packet::clear_response() {
  if (response_ != NULL) response_->::Impinj::STP::Response::Clear();
  clear_has_response();
}
inline const ::Impinj::STP::Response& Packet::response() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return response_ != NULL ? *response_ : *default_instance().response_;
#else
  return response_ != NULL ? *response_ : *default_instance_->response_;
#endif
}
inline ::Impinj::STP::Response* Packet::mutable_response() {
  set_has_response();
  if (response_ == NULL) response_ = new ::Impinj::STP::Response;
  return response_;
}
inline ::Impinj::STP::Response* Packet::release_response() {
  clear_has_response();
  ::Impinj::STP::Response* temp = response_;
  response_ = NULL;
  return temp;
}
inline void Packet::set_allocated_response(::Impinj::STP::Response* response) {
  delete response_;
  response_ = response;
  if (response) {
    set_has_response();
  } else {
    clear_has_response();
  }
}

// optional .Impinj.STP.Report report = 5;
inline bool Packet::has_report() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void Packet::set_has_report() {
  _has_bits_[0] |= 0x00000004u;
}
inline void Packet::clear_has_report() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void Packet::clear_report() {
  if (report_ != NULL) report_->::Impinj::STP::Report::Clear();
  clear_has_report();
}
inline const ::Impinj::STP::Report& Packet::report() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return report_ != NULL ? *report_ : *default_instance().report_;
#else
  return report_ != NULL ? *report_ : *default_instance_->report_;
#endif
}
inline ::Impinj::STP::Report* Packet::mutable_report() {
  set_has_report();
  if (report_ == NULL) report_ = new ::Impinj::STP::Report;
  return report_;
}
inline ::Impinj::STP::Report* Packet::release_report() {
  clear_has_report();
  ::Impinj::STP::Report* temp = report_;
  report_ = NULL;
  return temp;
}
inline void Packet::set_allocated_report(::Impinj::STP::Report* report) {
  delete report_;
  report_ = report;
  if (report) {
    set_has_report();
  } else {
    clear_has_report();
  }
}

// optional .Impinj.STP.Update update = 6;
inline bool Packet::has_update() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void Packet::set_has_update() {
  _has_bits_[0] |= 0x00000008u;
}
inline void Packet::clear_has_update() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void Packet::clear_update() {
  if (update_ != NULL) update_->::Impinj::STP::Update::Clear();
  clear_has_update();
}
inline const ::Impinj::STP::Update& Packet::update() const {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  return update_ != NULL ? *update_ : *default_instance().update_;
#else
  return update_ != NULL ? *update_ : *default_instance_->update_;
#endif
}
inline ::Impinj::STP::Update* Packet::mutable_update() {
  set_has_update();
  if (update_ == NULL) update_ = new ::Impinj::STP::Update;
  return update_;
}
inline ::Impinj::STP::Update* Packet::release_update() {
  clear_has_update();
  ::Impinj::STP::Update* temp = update_;
  update_ = NULL;
  return temp;
}
inline void Packet::set_allocated_update(::Impinj::STP::Update* update) {
  delete update_;
  update_ = update;
  if (update) {
    set_has_update();
  } else {
    clear_has_update();
  }
}


// @@protoc_insertion_point(namespace_scope)

}  // namespace STP
}  // namespace Impinj

// @@protoc_insertion_point(global_scope)

#endif  // PROTOBUF_stp_5fapi_2eproto__INCLUDED
